Code Review / o-du / l2.git / blob
? search:


7398c2006b3ef31533ec5720cf98dcb810f00d55
[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 #ifdef UNUSED_FUNC
161 #ifndef LTE_TDD
162 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
163 (
164 RgSchCellCb        *cell,
165 RgSchUeCb          *ue,
166 RgSchDlSf          *dlSf,
167 U8                 rbStrt,
168 U8                 numRb
169 );
170 PRIVATE S16 rgSCHCmnBuildRntpInfo (
171 RgSchCellCb        *cell,
172 U8                 *rntpPtr,
173 U8                  startRb,
174 U8                  nmbRb,
175 U16                 bw
176 );
177 #endif
178 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
179 (
180 RgSchCellCb        *cell,
181 RgSchDlSf          *dlSf,
182 RgSchDlRbAlloc     *allocInfo,
183 RgSchUeCb          *ue
184 );
185 PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
186 PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
187 RgSchCmnUlCell  *cellUl,
188 RgSchUlAlloc    *alloc,
189 U8               idx
190 ));
191 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
192 RgSchCellCb *cell,
193 RgSchUlSf   *sf
194 ));
195
196 #ifdef TFU_UPGRADE
197 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
198 RgSchCellCb  *cell,
199 RgSchUeCb    *ue,
200 U32          maxRb,
201 U32          *numSb,
202 U8           *iTbs,
203 U32          hqSz,
204 U32          stepDownItbs,
205 U32          effTgt
206 ));
207 #endif
208 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
209 RgSchCellCb                *cell,
210 RgSchDlRbAlloc             *rbAllocInfo,
211 RgSchDlHqProcCb            *hqP,
212 RgSchPdcch                 *pdcch,
213 U8                         tpc
214 ));
215 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
216 RgSchCellCb                *cell,
217 RgSchDlRbAlloc             *rbAllocInfo,
218 RgSchDlHqProcCb            *hqP,
219 RgSchPdcch                 *pdcch,
220 U8                         tpc
221 ));
222 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
223 RgSchCellCb                *cell,
224 RgSchDlRbAlloc             *rbAllocInfo,
225 RgSchDlHqProcCb            *hqP,
226 RgSchPdcch                 *pdcch,
227 U8                         tpc
228 ));
229 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
230 RgSchCellCb                *cell,
231 RgSchDlRbAlloc             *rbAllocInfo,
232 RgSchDlHqProcCb            *hqP,
233 RgSchPdcch                 *pdcch,
234 U8                         tpc
235 ));
236 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
237 RgSchCellCb                *cell,
238 RgSchDlRbAlloc             *rbAllocInfo,
239 RgSchDlHqProcCb            *hqP,
240 RgSchPdcch                 *pdcch,
241 U8                         tpc
242 ));
243
244 #endif
245
246 PUBLIC Void rgSCHCmnDlSpsSch
247 (
248  RgSchCellCb        *cell
249 );
250 /* LTE_ADV_FLAG_REMOVED_END */
251
252 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc ARGS((
253 RgSchCellCb           *cell,
254 RgSchCmnDlRbAllocInfo *allocInfo
255 ));
256 PRIVATE Void rgSCHBcchPcchDlRbAlloc ARGS((
257 RgSchCellCb           *cell,
258 RgSchCmnDlRbAllocInfo *allocInfo
259 ));
260 PRIVATE Void rgSCHCmnDlBcchPcchAlloc ARGS((
261 RgSchCellCb  *cell
262 ));
263 #ifdef RGR_CQI_REPT
264 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
265  RgSchCellCb        *cell,
266  RgSchUeCb          *ue,
267  TfuDlCqiPucch      *pucchCqi,
268  RgrUeCqiRept       *ueCqiRept,
269  Bool               *isCqiAvail,
270  Bool               *is2ndCwCqiAvail
271  ));
272 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
273  RgSchCellCb        *cell,
274  RgSchUeCb          *ue,
275  TfuDlCqiPusch      *puschCqi,
276  RgrUeCqiRept       *ueCqiRept,
277  Bool               *isCqiAvail,
278  Bool               *is2ndCwCqiAvail
279  ));
280 #else
281 PRIVATE Void rgSCHCmnDlCqiOnPucchInd ARGS ((
282  RgSchCellCb        *cell,
283  RgSchUeCb          *ue,
284  TfuDlCqiPucch      *pucchCqi
285  ));
286 PRIVATE Void rgSCHCmnDlCqiOnPuschInd ARGS ((
287  RgSchCellCb        *cell,
288  RgSchUeCb          *ue,
289  TfuDlCqiPusch      *puschCqi
290  ));
291 #endif
292 /* ccpu00117452 - MOD - Changed macro name from
293    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
294 #ifdef RGR_CQI_REPT
295 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept ARGS((
296    RgSchCellCb        *cell,
297    RgSchUeCb          *ue,
298    RgrUeCqiRept        *ueCqiRept));
299 #endif /* End of RGR_CQI_REPT */
300 /* Fix: syed align multiple UEs to refresh at same time */
301 PRIVATE Void rgSCHCmnGetRefreshPer ARGS((
302    RgSchCellCb  *cell,
303    RgSchUeCb    *ue,
304    U32          *waitPer));
305 PRIVATE S16 rgSCHCmnApplyUeRefresh ARGS((
306 RgSchCellCb     *cell,
307 RgSchUeCb       *ue));
308 #ifdef DL_LA
309 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa ARGS
310 ((
311 RgSchCellCb   *cell,
312 RgSchUeCb     *ue
313 ));
314 PRIVATE Void rgSCHCheckAndSetTxScheme ARGS
315 ((
316 RgSchCellCb   *cell,
317 RgSchUeCb     *ue
318 ));
319 #endif
320
321 #ifdef LTE_TDD
322 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz ARGS
323 ((
324 RgSchCellCb    *cell,
325 U32             bo,
326 U8             *rb,
327 U8             *iTbs,
328 U8              lyr,
329 U8              cfi
330 ));
331
332 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
333 ((
334 RgSchCellCb    *cell,
335 U32             bo,
336 U8             *rb,
337 U8              maxRb,
338 U8             *iTbs1,
339 U8             *iTbs2,
340 U8              lyr1,
341 U8              lyr2,
342 U32            *tb1Sz, 
343 U32            *tb2Sz, 
344 U8              cfi
345 ));
346
347 #endif
348 PRIVATE Void  rgSCHCmnInitRbAlloc ARGS 
349 ((
350 RgSchCellCb        *cell
351 ));
352 #ifdef __cplusplus
353 }
354 #endif /* __cplusplus */
355
356
357 /* local defines */
358 PUBLIC  RgSchdApis          rgSchCmnApis;
359 PRIVATE RgUlSchdApis        rgSchUlSchdTbl[RGSCH_NUM_SCHEDULERS];
360 PRIVATE RgDlSchdApis        rgSchDlSchdTbl[RGSCH_NUM_SCHEDULERS];
361 #ifdef EMTC_ENABLE
362 PRIVATE RgUlSchdApis        rgSchEmtcUlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
363 PRIVATE RgDlEmtcSchdApis        rgSchEmtcDlSchdTbl[RGSCH_NUM_EMTC_SCHEDULERS];
364 #endif
365 #ifdef RG_PHASE2_SCHED
366 PRIVATE RgDlfsSchdApis      rgSchDlfsSchdTbl[RGSCH_NUM_DLFS_SCHEDULERS];
367 #endif
368 PRIVATE RgUlSchdInits       rgSchUlSchdInits = RGSCH_ULSCHED_INITS;
369 PRIVATE RgDlSchdInits       rgSchDlSchdInits = RGSCH_DLSCHED_INITS;
370 #ifdef EMTC_ENABLE
371 PRIVATE RgEmtcUlSchdInits       rgSchEmtcUlSchdInits = RGSCH_EMTC_ULSCHED_INITS;
372 PRIVATE RgEmtcDlSchdInits       rgSchEmtcDlSchdInits = RGSCH_EMTC_DLSCHED_INITS;
373 #endif
374 #if (defined (RG_PHASE2_SCHED) && defined (TFU_UPGRADE))
375 PRIVATE RgDlfsSchdInits     rgSchDlfsSchdInits = RGSCH_DLFSSCHED_INITS;
376 #endif
377
378 typedef Void (*RgSchCmnDlAllocRbFunc) ARGS((RgSchCellCb *cell, RgSchDlSf *subFrm,
379 RgSchUeCb *ue, U32 bo, U32 *effBo, RgSchDlHqProcCb *proc,
380 RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
381 typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, 
382       U8 numLyrs, Bool bothCwEnbld));
383 PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
384 RgSchCellCb                *cell,
385 RgSchDlSf                  *subFrm,
386 RgSchUeCb                  *ue,
387 U32                        bo,
388 U32                        *effBo,
389 RgSchDlHqProcCb            *proc,
390 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
391 ));
392 PRIVATE Void rgSCHCmnDlAllocTxRbTM2 ARGS((
393 RgSchCellCb                *cell,
394 RgSchDlSf                  *subFrm,
395 RgSchUeCb                  *ue,
396 U32                        bo,
397 U32                        *effBo,
398 RgSchDlHqProcCb            *proc,
399 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
400 ));
401 PRIVATE Void rgSCHCmnDlAllocTxRbTM3 ARGS((
402 RgSchCellCb                *cell,
403 RgSchDlSf                  *subFrm,
404 RgSchUeCb                  *ue,
405 U32                        bo,
406 U32                        *effBo,
407 RgSchDlHqProcCb            *proc,
408 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
409 ));
410 PRIVATE Void rgSCHCmnDlAllocTxRbTM4 ARGS((
411 RgSchCellCb                *cell,
412 RgSchDlSf                  *subFrm,
413 RgSchUeCb                  *ue,
414 U32                        bo,
415 U32                        *effBo,
416 RgSchDlHqProcCb            *proc,
417 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
418 ));
419 #ifdef RG_UNUSED
420 PRIVATE Void rgSCHCmnDlAllocTxRbTM5 ARGS((
421 RgSchCellCb                *cell,
422 RgSchDlSf                  *subFrm,
423 RgSchUeCb                  *ue,
424 U32                        bo,
425 U32                        *effBo,
426 RgSchDlHqProcCb            *proc,
427 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
428 ));
429 #endif
430 PRIVATE Void rgSCHCmnDlAllocTxRbTM6 ARGS((
431 RgSchCellCb                *cell,
432 RgSchDlSf                  *subFrm,
433 RgSchUeCb                  *ue,
434 U32                        bo,
435 U32                        *effBo,
436 RgSchDlHqProcCb            *proc,
437 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
438 ));
439 PRIVATE Void rgSCHCmnDlAllocTxRbTM7 ARGS((
440 RgSchCellCb                *cell,
441 RgSchDlSf                  *subFrm,
442 RgSchUeCb                  *ue,
443 U32                        bo,
444 U32                        *effBo,
445 RgSchDlHqProcCb            *proc,
446 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
447 ));
448 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1 ARGS((
449 RgSchCellCb                *cell,
450 RgSchDlSf                  *subFrm,
451 RgSchUeCb                  *ue,
452 U32                        bo,
453 U32                        *effBo,
454 RgSchDlHqProcCb            *proc,
455 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
456 ));
457 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2 ARGS((
458 RgSchCellCb                *cell,
459 RgSchDlSf                  *subFrm,
460 RgSchUeCb                  *ue,
461 U32                        bo,
462 U32                        *effBo,
463 RgSchDlHqProcCb            *proc,
464 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
465 ));
466 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3 ARGS((
467 RgSchCellCb                *cell,
468 RgSchDlSf                  *subFrm,
469 RgSchUeCb                  *ue,
470 U32                        bo,
471 U32                        *effBo,
472 RgSchDlHqProcCb            *proc,
473 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
474 ));
475 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4 ARGS((
476 RgSchCellCb                *cell,
477 RgSchDlSf                  *subFrm,
478 RgSchUeCb                  *ue,
479 U32                        bo,
480 U32                        *effBo,
481 RgSchDlHqProcCb            *proc,
482 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
483 ));
484 #ifdef RG_UNUSED
485 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5 ARGS((
486 RgSchCellCb                *cell,
487 RgSchDlSf                  *subFrm,
488 RgSchUeCb                  *ue,
489 U32                        bo,
490 U32                        *effBo,
491 RgSchDlHqProcCb            *proc,
492 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
493 ));
494 #endif
495 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6 ARGS((
496 RgSchCellCb                *cell,
497 RgSchDlSf                  *subFrm,
498 RgSchUeCb                  *ue,
499 U32                        bo,
500 U32                        *effBo,
501 RgSchDlHqProcCb            *proc,
502 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
503 ));
504 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7 ARGS((
505 RgSchCellCb                *cell,
506 RgSchDlSf                  *subFrm,
507 RgSchUeCb                  *ue,
508 U32                        bo,
509 U32                        *effBo,
510 RgSchDlHqProcCb            *proc,
511 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
512 ));
513
514 #ifdef LTE_ADV 
515 PRIVATE U8 rgSchGetN1ResCount ARGS ((
516  RgSchUeCb *ue,
517  U16       servCellId 
518 ));
519 PUBLIC Bool rgSchCmnChkDataOnlyOnPcell 
520 (
521  RgSchUeCb         *ue,
522  RgSchDlSf         *dlSf
523 );
524 #endif /*LTE_ADV */
525 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
526 (
527  RgSchUeCb    *ueCb, 
528  U8           numTxAnt
529 );
530
531 #ifndef LTE_ADV
532 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
533 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[7] = {rgSCHCmnDlAllocTxRbTM1,
534 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
535 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7};
536
537 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
538 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[7] = {rgSCHCmnDlAllocRetxRbTM1,
539 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
540 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7};
541 #else
542 /* Functions specific to each transmission mode for DL Tx RB Allocation*/
543 RgSchCmnDlAllocRbFunc  dlAllocTxRbFunc[9] = {rgSCHCmnDlAllocTxRbTM1,
544 rgSCHCmnDlAllocTxRbTM2, rgSCHCmnDlAllocTxRbTM3, rgSCHCmnDlAllocTxRbTM4,
545 NULLP, rgSCHCmnDlAllocTxRbTM6, rgSCHCmnDlAllocTxRbTM7, NULLP, NULLP};
546
547 /* Functions specific to each transmission mode for DL Retx RB Allocation*/
548 RgSchCmnDlAllocRbFunc  dlAllocRetxRbFunc[9] = {rgSCHCmnDlAllocRetxRbTM1,
549 rgSCHCmnDlAllocRetxRbTM2, rgSCHCmnDlAllocRetxRbTM3, rgSCHCmnDlAllocRetxRbTM4,
550 NULLP, rgSCHCmnDlAllocRetxRbTM6, rgSCHCmnDlAllocRetxRbTM7, NULLP, NULLP};
551
552 #endif
553
554
555 PRIVATE U8 rgSCHCmnDlTM3PrecInf2 ARGS((
556 RgSchCellCb                *cell,
557 RgSchUeCb                  *ue,
558 U8                         numTxLyrs,
559 Bool                       bothCwEnbld
560 ));
561 PRIVATE U8 rgSCHCmnDlTM3PrecInf4 ARGS((
562 RgSchCellCb                *cell,
563 RgSchUeCb                  *ue,
564 U8                         numTxLyrs,
565 Bool                       bothCwEnbld
566 ));
567 PRIVATE U8 rgSCHCmnDlTM4PrecInf2 ARGS((
568 RgSchCellCb                *cell,
569 RgSchUeCb                  *ue,
570 U8                         numTxLyrs,
571 Bool                       bothCwEnbld
572 ));
573 PRIVATE U8 rgSCHCmnDlTM4PrecInf4 ARGS((
574 RgSchCellCb                *cell,
575 RgSchUeCb                  *ue,
576 U8                         numTxLyrs,
577 Bool                       bothCwEnbld
578 ));
579 /* Functions specific to each transmission mode for DL RB Allocation*/
580 RgSchCmnDlGetPrecInfFunc getPrecInfoFunc[2][2] = {
581 {rgSCHCmnDlTM3PrecInf2, rgSCHCmnDlTM3PrecInf4},
582 {rgSCHCmnDlTM4PrecInf2, rgSCHCmnDlTM4PrecInf4}
583 };
584
585 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb ARGS((
586 RgSchCellCb                *cell,
587 RgSchDlSf                  *subFrm,
588 RgSchUeCb                  *ue,
589 RgSchDlHqTbCb              *tbInfo,
590 U8                         noLyr,
591 U8                         *numRb,
592 U32                        *effBo
593 ));
594 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
595 RgSchCellCb                *cell,
596 RgSchDlSf                  *subFrm,
597 RgSchUeCb                  *ue,
598 RgSchDlHqProcCb            *proc,
599 U8                         *numRb,
600 Bool                       *swpFlg,
601 U32                        *effBo
602 ));
603 PRIVATE Void rgSCHCmnDlTM3TxTx ARGS((
604 RgSchCellCb                *cell,
605 RgSchDlSf                  *subFrm,
606 RgSchUeCb                  *ue,
607 U32                        bo,
608 U32                        *effBo,
609 RgSchDlHqProcCb            *proc,
610 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
611 ));
612 PRIVATE Void rgSCHCmnDlTM3TxRetx ARGS((
613 RgSchCellCb                *cell,
614 RgSchDlSf                  *subFrm,
615 RgSchUeCb                  *ue,
616 U32                        bo,
617 U32                        *effBo,
618 RgSchDlHqProcCb            *proc,
619 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
620 ));
621 PRIVATE Void rgSCHCmnDlTM3RetxRetx ARGS((
622 RgSchCellCb                *cell,
623 RgSchDlSf                  *subFrm,
624 RgSchUeCb                  *ue,
625 U32                        bo,
626 U32                        *effBo,
627 RgSchDlHqProcCb            *proc,
628 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
629 ));
630
631 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
632 RgSchCellCb        *cell,
633 RgSchDlSf          *dlSf,
634 U8                 rbStrt,
635 U8                 numRb
636 ));
637 /* LTE_ADV_FLAG_REMOVED_START */
638 #ifndef LTE_TDD
639 PRIVATE Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
640 RgSchCellCb        *cell,
641 RgSchDlSf          *dlSf,
642 U8                 rbStrt,
643 U8                 numRb
644 ));
645 #endif
646 /* LTE_ADV_FLAG_REMOVED_END */
647 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx ARGS((
648 RgSchCellCb        *cell,
649 RgSchCmnDlRbAllocInfo *allocInfo,
650 RgSchUeCb             *ue,
651 RgSchDlHqProcCb       *proc
652 ));
653 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx ARGS((
654 RgSchCellCb        *cell,
655 RgSchCmnDlRbAllocInfo *allocInfo,
656 RgSchUeCb             *ue,
657 RgSchDlHqProcCb       *hqP
658 ));
659 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst ARGS((
660 RgSchCmnDlRbAllocInfo *allocInfo,
661 RgSchUeCb             *ue,
662 RgSchDlHqProcCb       *proc
663 ));
664 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb ARGS((
665 RgSchCellCb                *cell,
666 RgSchDlSf                  *subFrm,
667 RgSchUeCb                  *ue,
668 RgSchDlHqTbCb              *reTxTb,
669 RgSchDlHqTbCb              *txTb,
670 U8                         *numRb,
671 U32                        *effBo
672 ));
673 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
674 RgSchCellCb                *cell,
675 RgSchDlSf                  *subFrm,
676 RgSchUeCb                  *ue,
677 RgSchDlHqProcCb            *proc,
678 U32                        bo,
679 U8                         *numRb,
680 U32                        *effBo
681 ));
682 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
683 RgSchCellCb                *cell,
684 RgSchDlSf                  *subFrm,
685 RgSchUeCb                  *ue,
686 RgSchDlHqTbCb              *tbInfo,
687 U32                        bo,
688 U8                         *numRb,
689 U32                        *effBo
690 ));
691 #ifndef LTEMAC_SPS
692 PRIVATE Void rgSCHCmnFillHqPTb ARGS((
693 RgSchCellCb                *cell,
694 RgSchDlRbAlloc             *rbAllocInfo,
695 U8                         tbAllocIdx,
696 RgSchPdcch                 *pdcch
697 ));
698 #endif
699 #ifdef LTEMAC_SPS
700 PRIVATE Void rgSCHCmnDlGetBestFitHole ARGS((
701 U32         *allocMask,
702 U8          numMaskRbs,
703 U32         *crntAllocMask,
704 U8          rbsReq,
705 U8          *allocStart,
706 U8          *allocNumRbs,
707 Bool        isPartialAlloc
708 ));
709 #ifdef RGSCH_SPS_UNUSED
710 PRIVATE U32 rgSCHCmnGetRaType1Mask ARGS((
711 U8                rbIdx,
712 U8                rbgSize,
713 U8                *type1Subset
714 ));
715 #endif
716 PRIVATE U32 rgSCHCmnGetRaType0Mask ARGS((
717 U8                rbIdx,
718 U8                rbgSize
719 ));
720 PRIVATE U32 rgSCHCmnGetRaType2Mask ARGS((
721 U8                rbIdx,
722 U8                *maskIdx
723 ));
724 #endif
725
726 PUBLIC Bool rgSCHCmnRetxAllocAvoid ARGS(( 
727 RgSchDlSf                  *subFrm,
728 RgSchCellCb                *cell,
729 RgSchDlHqProcCb            *proc
730 ));
731
732 PUBLIC U16 rgSCHCmnGetSiSetId ARGS((
733 U16    sfn,
734 U8     sf,
735 U16    minPeriodicity
736 ));
737
738
739 #ifdef RG_5GTF
740 //TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
741 U32 rgSch5gtfTbSzTbl[MAX_5GTF_MCS] = 
742     {1864, 5256, 8776, 13176, 17576, 21976, 26376, 31656, 35176, 39576, 43976, 47496, 52776, 59376, 66392};
743 U32 g5gtfTtiCnt = 0;
744 U32 gUl5gtfSrRecv = 0;
745 U32 gUl5gtfBsrRecv = 0;
746 U32 gUl5gtfUeSchPick = 0;
747 U32 gUl5gtfPdcchSchd = 0;
748 U32 gUl5gtfAllocAllocated = 0;
749 U32 gUl5gtfUeRbAllocDone = 0;
750 U32 gUl5gtfUeRmvFnlzZeroBo = 0;
751 U32 gUl5gtfUeFnlzReAdd = 0;
752 U32 gUl5gtfPdcchSend = 0;
753 U32 gUl5gtfRbAllocFail = 0;
754 U32 ul5gtfsidUlMarkUl = 0;
755 U32 ul5gtfsidDlSchdPass = 0;
756 U32 ul5gtfsidDlAlreadyMarkUl = 0;
757 U32 ul5gtfTotSchdCnt = 0;
758 #endif
759
760 /* CQI Offset Index to Beta CQI Offset value mapping,
761  * stored as parts per 1000. Reserved is set to 0.
762  * Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
763 PUBLIC U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
764    1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
765    3125, 3500, 4000, 5000, 6250};
766 PUBLIC U32 rgSchCmnBetaHqOffstTbl[16] =  {2000, 2500, 3125, 
767    4000, 5000, 6250, 8000,10000, 12625, 15875, 20000, 
768    31000, 50000,80000,126000,0};
769 PUBLIC U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000, 
770    2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
771    15875,20000,0,0,0};
772 PUBLIC S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
773
774 /* Include CRS REs while calculating Efficiency */
775 CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
776 CONSTANT PRIVATE U8 rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
777 U32 cfiSwitchCnt ;
778 U32 cfiIncr ;
779 U32 cfiDecr ;
780
781
782 #ifdef TFU_UPGRADE
783 PUBLIC S8 rgSchCmnApUeSelDiffCqi[4] = {1, 2, 3, 4};
784 PUBLIC S8 rgSchCmnApEnbConfDiffCqi[4] = {0, 1, 2, -1};
785 #endif
786
787 typedef struct rgSchCmnDlUeDciFrmtOptns
788 {
789   TfuDciFormat spfcDciFrmt;   /* TM(Transmission Mode) specific DCI format.
790                                * Search space : UE Specific by C-RNTI only. */
791   U8           spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
792   TfuDciFormat prfrdDciFrmt;  /* Preferred DCI format among the available
793                                * options for TD (Transmit Diversity) */
794   U8           prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
795 }RgSchCmnDlUeDciFrmtOptns;
796 #ifndef LTE_ADV
797
798 /* DCI Format options for each Transmission Mode */
799 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[7] = {
800    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
801    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
802    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
803    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
804    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
805    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
806    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
807 };
808
809 #else
810 /* DCI Format options for each Transmission Mode */
811 RgSchCmnDlUeDciFrmtOptns rgSchCmnDciFrmtOptns[9] = {
812    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
813    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
814    {TFU_DCI_FORMAT_2A,RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
815    {TFU_DCI_FORMAT_2, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
816    {TFU_DCI_FORMAT_1D,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
817    {TFU_DCI_FORMAT_1B,RG_SCH_CMN_RA_TYPE2, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2},
818    {TFU_DCI_FORMAT_1, RG_SCH_CMN_RA_TYPE0, TFU_DCI_FORMAT_1A, RG_SCH_CMN_RA_TYPE2}
819 };
820 #endif
821
822
823 typedef struct rgSchCmnDlImcsTbl
824 {
825   U8   modOdr; /* Modulation Order */
826   U8   iTbs;   /* ITBS */
827 }RgSchCmnDlImcsTbl[29];
828
829 CONSTANT struct rgSchCmnMult235Info
830 {
831    U8   match;    /* Closest number satisfying 2^a.3^b.5^c, with a bias
832                   * towards the smaller number */
833    U8   prvMatch; /* Closest number not greater than array index
834                   * satisfying 2^a.3^b.5^c */
835 } rgSchCmnMult235Tbl[110+1] = {
836    {0, 0},  /* dummy */
837    {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {6, 6}, {8, 8},
838    {9, 9}, {10, 10}, {10, 10}, {12, 12}, {12, 12}, {15, 12}, {15, 15},
839    {16, 16}, {16, 16}, {18, 18}, {18, 18}, {20, 20}, {20, 20}, {20, 20},
840    {24, 20}, {24, 24}, {25, 25}, {25, 25}, {27, 27}, {27, 27}, {30, 27},
841    {30, 30}, {30, 30}, {32, 32}, {32, 32}, {32, 32}, {36, 32}, {36, 36},
842    {36, 36}, {36, 36}, {40, 36}, {40, 40}, {40, 40}, {40, 40}, {45, 40},
843    {45, 40}, {45, 45}, {45, 45}, {48, 45}, {48, 48}, {48, 48}, {50, 50},
844    {50, 50}, {50, 50}, {54, 50}, {54, 54}, {54, 54}, {54, 54}, {54, 54},
845    {60, 54}, {60, 54}, {60, 60}, {60, 60}, {60, 60}, {64, 60}, {64, 64},
846    {64, 64}, {64, 64}, {64, 64}, {64, 64}, {72, 64}, {72, 64}, {72, 64},
847    {72, 72}, {72, 72}, {75, 72}, {75, 75}, {75, 75}, {75, 75}, {80, 75},
848    {80, 75}, {80, 80}, {81, 81}, {81, 81}, {81, 81}, {81, 81}, {81, 81},
849    {90, 81}, {90, 81}, {90, 81}, {90, 81}, {90, 90}, {90, 90}, {90, 90},
850    {90, 90}, {96, 90}, {96, 90}, {96, 96}, {96, 96}, {96, 96}, {100, 96},
851    {100, 100}, {100, 100}, {100, 100}, {100, 100}, {100, 100}, {108, 100},
852    {108, 100}, {108, 100}, {108, 108}, {108, 108}, {108, 108}
853 };
854
855 /* R8 Upgrade */
856 /* BI table from 36.321 Table 7.2.1 */
857 CONSTANT PRIVATE S16 rgSchCmnBiTbl[RG_SCH_CMN_NUM_BI_VAL] = {
858       0, 10, 20, 30,40,60,80,120,160,240,320,480,960};
859 PUBLIC RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI] = {
860  {     0,                0              },
861  {RGSCH_CMN_QM_CQI_1,RGSCH_CMN_UL_EFF_CQI_1 },
862  {RGSCH_CMN_QM_CQI_2,RGSCH_CMN_UL_EFF_CQI_2 },
863  {RGSCH_CMN_QM_CQI_3,RGSCH_CMN_UL_EFF_CQI_3 },
864  {RGSCH_CMN_QM_CQI_4,RGSCH_CMN_UL_EFF_CQI_4 },
865  {RGSCH_CMN_QM_CQI_5,RGSCH_CMN_UL_EFF_CQI_5 },
866  {RGSCH_CMN_QM_CQI_6,RGSCH_CMN_UL_EFF_CQI_6 },
867  {RGSCH_CMN_QM_CQI_7,RGSCH_CMN_UL_EFF_CQI_7 },
868  {RGSCH_CMN_QM_CQI_8,RGSCH_CMN_UL_EFF_CQI_8 },
869  {RGSCH_CMN_QM_CQI_9,RGSCH_CMN_UL_EFF_CQI_9 },
870  {RGSCH_CMN_QM_CQI_10,RGSCH_CMN_UL_EFF_CQI_10 },
871  {RGSCH_CMN_QM_CQI_11,RGSCH_CMN_UL_EFF_CQI_11 },
872  {RGSCH_CMN_QM_CQI_12,RGSCH_CMN_UL_EFF_CQI_12 },
873  {RGSCH_CMN_QM_CQI_13,RGSCH_CMN_UL_EFF_CQI_13 },
874  {RGSCH_CMN_QM_CQI_14,RGSCH_CMN_UL_EFF_CQI_14 },
875  {RGSCH_CMN_QM_CQI_15,RGSCH_CMN_UL_EFF_CQI_15 },
876 };
877
878 #ifdef RG_UNUSED
879 /* This table maps a (delta_offset * 2 + 2) to a (beta * 8)
880  * where beta is 10^-(delta_offset/10) rounded off to nearest 1/8
881  */
882 PRIVATE U16 rgSchCmnUlBeta8Tbl[29] = {
883    6, RG_SCH_CMN_UL_INVALID_BETA8, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23,
884    25, 28, 32, RG_SCH_CMN_UL_INVALID_BETA8, 40, RG_SCH_CMN_UL_INVALID_BETA8,
885    50, RG_SCH_CMN_UL_INVALID_BETA8, 64, RG_SCH_CMN_UL_INVALID_BETA8, 80,
886    RG_SCH_CMN_UL_INVALID_BETA8, 101, RG_SCH_CMN_UL_INVALID_BETA8, 127,
887    RG_SCH_CMN_UL_INVALID_BETA8, 160
888 };
889 #endif
890
891 /* QCI to SVC priority mapping. Index specifies the Qci*/
892 PRIVATE U8 rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
893
894 /* The configuration is efficiency measured per 1024 REs.  */
895 /* The first element stands for when CQI is not known      */
896 /* This table is used to translate CQI to its corrospoding */
897 /* allocation parameters. These are currently from 36.213  */
898 /* Just this talbe needs to be edited for modifying the    */
899 /* the resource allocation behaviour                       */
900
901 /* ADD CQI to MCS mapping correction
902  * single dimensional array is replaced by 2 dimensions for different CFI*/
903 PRIVATE U16 rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
904     RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI2,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI3};
905
906 PRIVATE U16 rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
907     RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI2, RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI3};
908
909 /* This configuration determines the transalation of a UEs CQI to its    */
910 /* PDCCH coding efficiency. This may be edited based on the installation */
911 PRIVATE U8 rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
912
913 /* Indexed by [DciFrmt].
914  * Considering the following definition in determining the dciFrmt index.
915  * typedef enum
916 {
917    TFU_DCI_FORMAT_0,
918    TFU_DCI_FORMAT_1,
919    TFU_DCI_FORMAT_1A,
920    TFU_DCI_FORMAT_1B,
921    TFU_DCI_FORMAT_1C,
922    TFU_DCI_FORMAT_1D,
923    TFU_DCI_FORMAT_2,
924    TFU_DCI_FORMAT_2A,
925    TFU_DCI_FORMAT_3,
926    TFU_DCI_FORMAT_3A
927 } TfuDciFormat;
928 */
929 PRIVATE U16 rgSchCmnDciFrmtSizes[10];
930
931
932 PRIVATE U16 rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
933
934 #ifdef LTE_TDD
935
936 PUBLIC RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl = {
937    {RG_SCH_TDD_DL_SUBFRAME, RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_DL_SUBFRAME,  RG_SCH_TDD_SPL_SUBFRAME, RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME,  RG_SCH_TDD_UL_SUBFRAME},
938    {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},
939    {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},
940    {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},
941    {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},
942    {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},
943    {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}
944 };
945
946 /* SPS_INTG_FIX */
947 #ifdef LTEMAC_SPS
948 PUBLIC U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
949    /* 0 */ 6,
950    /* 1 */ 7,
951    /* 2 */ 8,
952    /* 3 */ 11,
953    /* 4 */ 12,
954    /* 5 */ 13,
955    /* 6 */ 7};
956
957 #endif
958
959
960 /* Special Subframes in OFDM symbols */
961 /* ccpu00134197-MOD-Correct the number of symbols */
962 PUBLIC RgSchTddSplSubfrmInfoTbl rgSchTddSplSubfrmInfoTbl = {
963         {3,  1, 1, 3,   1, 1},
964         {9,  1, 1, 8,   1, 1},
965         {10, 1, 1, 9,   1, 1},
966         {11, 1, 1, 10,  1, 1},
967         {12, 1, 1, 3,   2, 2},
968         {3,  2, 2, 8,   2, 2},
969         {9,  2, 2, 9,   2, 2},
970         {10, 2, 2, 0,   0, 0},
971         {11, 2, 2, 0,   0, 0}
972 };
973
974 /* PHICH 'm' value Table */
975 PUBLIC RgSchTddPhichMValTbl rgSchTddPhichMValTbl = {
976         {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
977         {0, 1, 0, 0, 1, 0, 1, 0, 0, 1},
978         {0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
979         {1, 0, 0, 0, 0, 0, 0, 0, 1, 1},
980         {0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
981         {0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
982         {1, 1, 0, 0, 0, 1, 1, 0, 0, 1}
983 };
984
985 /* PHICH 'K' value Table */
986 PUBLIC RgSchTddKPhichTbl rgSchTddKPhichTbl = {
987         {0, 0, 4, 7, 6, 0, 0, 4, 7, 6},
988         {0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
989         {0, 0, 6, 0, 0, 0, 0, 6, 0, 0},
990         {0, 0, 6, 6, 6, 0, 0, 0, 0, 0},
991         {0, 0, 6, 6, 0, 0, 0, 0, 0, 0},
992         {0, 0, 6, 0, 0, 0, 0, 0, 0, 0},
993         {0, 0, 4, 6, 6, 0, 0, 4, 7, 0}
994 };
995
996 /* Uplink association index 'K' value Table */
997 PUBLIC RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl = {
998         {0, 0, 6, 4, 0, 0, 0, 6, 4, 0},
999         {0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
1000         {0, 0, 4, 4, 4, 0, 0, 0, 0, 0},
1001         {0, 0, 4, 4, 0, 0, 0, 0, 0, 0},
1002         {0, 0, 4, 0, 0, 0, 0, 0, 0, 0},
1003         {0, 0, 7, 7, 5, 0, 0, 7, 7, 0}
1004 };
1005
1006
1007 /* PUSCH 'K' value Table */
1008 PUBLIC RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl = {
1009         {4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
1010         {0, 6, 0, 0, 4, 0, 6, 0, 0, 4},
1011         {0, 0, 0, 4, 0, 0, 0, 0, 4, 0},
1012         {4, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1013         {0, 0, 0, 0, 0, 0, 0, 0, 4, 4},
1014         {0, 0, 0, 0, 0, 0, 0, 0, 4, 0},
1015         {7, 7, 0, 0, 0, 7, 7, 0, 0, 5}
1016 };
1017
1018 /* PDSCH to PUCCH Table for DL Harq Feed back. Based on the 
1019    Downlink association set index 'K' table */
1020 PUBLIC U8 rgSchTddPucchTxTbl[7][10] = {
1021         {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1022         {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1023         {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1024         {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1025         {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1026         {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1027         {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1028 };
1029
1030 /* Table to fetch the next DL sf idx for applying the 
1031    new CFI. The next Dl sf Idx at which the new CFI 
1032    is applied is always the starting Sf of the next ACK/NACK
1033    Fdbk bundle. 
1034    
1035    Ex: In Cfg-2, sf4 and sf9 are the only subframes at which 
1036        a new ACK/NACK bundle of DL subframes can start
1037        
1038    D  S  U  D  D  D  S  U  D  D  D  S  U  D  D  D  S  U  D  D    
1039                4              9
1040    
1041    dlSf Array for Cfg-2:
1042    sfNum:  0  1  3  4  5  6  8  9  0  1   3  4  5  6  8  9 
1043    sfIdx:  0  1  2  3  4  5  6  7  8  9  10 11 12 12 14 15 
1044     
1045    If CFI changes at sf0,  nearest DL SF bundle >= 4 TTI is sf4
1046    So at sf4 the new CFI can be applied. To arrive at sf4 from
1047    sf0, the sfIdx has to be increased by 3 */  
1048                  
1049 PUBLIC U8 rgSchTddPdcchSfIncTbl[7][10] = {
1050  /* A/N Bundl: 0,1,5,6*/   {2,  1,  0, 0, 0, 2, 1,  0,  0,  0},
1051  /* A/N Bundl: 0,4,5,9*/   {2,  2,  0, 0, 3, 2, 2,  0,  0,  3},
1052  /* A/N Bundl: 4,9*/       {3,  6,  0, 5, 4, 3, 6,  0,  5,  4},
1053  /* A/N Bundl: 1,7,9*/     {4,  3,  0, 0, 0, 4, 5,  4,  6,  5},
1054  /* A/N Bundl: 0,6*/       {4,  3,  0, 0, 6, 5, 4,  7,  6,  5},
1055  /* A/N Bundl: 9*/         {8,  7,  0, 6, 5, 4, 12, 11, 10, 9},
1056  /* A/N Bundl: 0,1,5,6,9*/ {2,  1,  0, 0, 0, 2, 2,  0,  0,  3}
1057 };
1058    
1059
1060 /* combine compilation fixes */
1061 #ifdef LTEMAC_SPS
1062 /* subframe offset values to be used when twoIntervalsConfig is enabled in UL
1063  * SPS for a UE */
1064 PUBLIC RgSchTddSfOffTbl rgSchTddSfOffTbl = {
1065         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1066         {0, 0, 1, -1,  0, 0, 0,  1, -1, 0},
1067         {0, 0, 5,  0,  0, 0, 0, -5,  0, 0},
1068         {0, 0, 1,  1, -2, 0, 0,  0,  0, 0},
1069         {0, 0, 1, -1,  0, 0, 0,  0,  0, 0},
1070         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0},
1071         {0, 0, 0,  0,  0, 0, 0,  0,  0, 0}
1072 };
1073
1074
1075 /* Table to determine when uplink SPS configured grants should
1076  * explicitly be reserved in a subframe. When enries are same
1077  * as that of Msg3SubfrmTbl, indicates competition with msg3.
1078  * As of now, this is same as Msg3SubfrmTbl (leaving out uldlcfg 2),
1079  * except that all 255s are now zeros. */
1080 PUBLIC RgSchTddSpsUlRsrvTbl rgSchTddSpsUlRsrvTbl = {
1081         {0,    0,  0,  6,  8,  0, 0,  0,  6,  8},
1082         {0,    0,  6,  9,  0,  0, 0,  6,  9,  0},
1083         {0,    0,  10,  0,  0,  0, 0,  10,  0,  0},
1084         {0,   0,  0,  0,  8,  0, 7,  7,  14,  0},
1085         {0,   0,  0,  9,  0,  0, 7,  15,  0, 0},
1086         {0,   0,  10,  0,  0,  0, 16,  0, 0, 0},
1087         {0,    0,  0,  0,  8,  0, 0,  0,  9,  0}
1088 };
1089
1090 /* Inverse DL Assoc Set index Table */
1091 PUBLIC RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl = {
1092        {4,  6,  0, 0, 0, 4, 6, 0, 0,  0},
1093        {7,  6,  0, 0, 4, 7, 6, 0, 0,  4},
1094        {7,  6,  0, 4, 8, 7, 6, 0, 4,  8},
1095        {4,  11, 0, 0, 0, 7, 6, 6, 5,  5},
1096        {12, 11, 0, 0, 8, 7, 7, 6, 5,  4},
1097        {12, 11, 0, 9, 8, 7, 6, 5, 4, 13},
1098        {7,  7,  0, 0, 0, 7, 7, 0, 0,  5}
1099 };
1100
1101 #endif /* (LTEMAC_SPS ) */
1102
1103 /* Number of Uplink subframes Table */
1104 PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
1105
1106 /* Downlink HARQ processes Table */
1107 PUBLIC RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
1108
1109 /* Uplink HARQ processes Table */
1110 PUBLIC RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl = { 4, 7, 10, 9, 12, 15, 6};
1111
1112 /* Downlink association index set 'K' value Table */
1113 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlAscSetIdxKTbl = {
1114         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1115
1116         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1117
1118         { {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}} },
1119
1120         { {0, {0}}, {0, {0}}, {3, {7, 6, 11}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1121
1122         { {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}} },
1123
1124         { {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}} },
1125
1126         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1127 };
1128
1129  /* ccpu132282-ADD-the table rgSchTddDlAscSetIdxKTbl is rearranged in 
1130   * decreasing order of Km, this is used to calculate the NCE used for 
1131   * calculating N1Pucch Resource for Harq*/
1132 PUBLIC RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl = {
1133         { {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}}, {0, {0}}, {0, {0}}, {1, {6}}, {0, {0}}, {1, {4}} },
1134
1135         { {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}}, {0, {0}}, {0, {0}}, {2, {7, 6}}, {1, {4}}, {0, {0}} },
1136
1137         { {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}} },
1138
1139         { {0, {0}}, {0, {0}}, {3, {11, 7, 6}}, {2, {6, 5}}, {2, {5, 4}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} },
1140
1141         { {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}} },
1142
1143         { {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}} },
1144
1145         { {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {1, {5}}, {0, {0}}, {0, {0}}, {1, {7}}, {1, {7}}, {0, {0}} }
1146 };
1147
1148 /* Minimum number of Ack/Nack feeback information to be
1149    stored for each UL-DL configuration */
1150 PUBLIC RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl = {4, 4, 2, 3, 2, 1, 5};
1151
1152 /* Uplink switch points and number of UL subframes Table */
1153 PUBLIC RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl = {
1154      {2,3,3}, {2,2,2}, {2,1,1}, {1,3,0}, {1,2,0}, {1,1,0}, {2,3,2}
1155 };
1156
1157 /* Uplink switch points and number of DL subframes Table */
1158 PUBLIC RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl = {
1159      {2,2,2}, {2,3,3}, {2,4,4}, {1,7,0}, {1,8,0}, {1,9,0}, {2,2,3}
1160 };
1161
1162 /* Number of UL subframes present before a particular subframe */
1163 PUBLIC RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl = {
1164         {0, 0, 1, 2, 3, 3, 3, 4, 5, 6},
1165         {0, 0, 1, 2, 2, 2, 2, 3, 4, 4},
1166         {0, 0, 1, 1, 1, 1, 1, 2, 2, 2},
1167         {0, 0, 1, 2, 3, 3, 3, 3, 3, 3},
1168         {0, 0, 1, 2, 2, 2, 2, 2, 2, 2},
1169         {0, 0, 1, 1, 1, 1, 1, 1, 1, 1},
1170         {0, 0, 1, 2, 3, 3, 3, 4, 5, 5}
1171 };
1172
1173 /* Number of DL subframes present till a particular subframe */
1174 PUBLIC RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl = {
1175         {1, 2, 2, 2, 2, 3, 4, 4, 4, 4},
1176         {1, 2, 2, 2, 3, 4, 5, 5, 5, 6},
1177         {1, 2, 2, 3, 4, 5, 6, 6, 7, 8},
1178         {1, 2, 2, 2, 2, 3, 4, 5, 6, 7},
1179         {1, 2, 2, 2, 3, 4, 5, 6, 7, 8},
1180         {1, 2, 2, 3, 4, 5, 6, 7, 8, 9},
1181         {1, 2, 2, 2, 2, 3, 4, 4, 4, 5}
1182 };
1183
1184
1185 /* Nearest possible UL subframe Index from UL subframe
1186  * DL Index < UL Index */
1187 PUBLIC RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl = {
1188         {0, 1, 1, 1, 1, 5, 6, 6, 6, 6},
1189         {0, 1, 1, 1, 4, 5, 6, 6, 6, 9},
1190         {0, 1, 1, 3, 4, 5, 6, 6, 8, 9},
1191         {0, 1, 1, 1, 1, 5, 6, 7, 8, 9},
1192         {0, 1, 1, 1, 4, 5, 6, 7, 8, 9},
1193         {0, 1, 1, 3, 4, 5, 6, 7, 8, 9},
1194         {0, 1, 1, 1, 1, 5, 6, 6, 6, 9}
1195 };
1196
1197 /* Nearest possible DL subframe Index from UL subframe
1198  * DL Index > UL Index
1199  * 10 represents Next SFN low DL Idx */
1200 PUBLIC RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl = {
1201         {0, 1, 5, 5, 5, 5, 6, 10, 10, 10},
1202         {0, 1, 4, 4, 4, 5, 6,  9,  9,  9},
1203         {0, 1, 3, 3, 4, 5, 6,  8,  8,  9},
1204         {0, 1, 5, 5, 5, 5, 6,  7,  8,  9},
1205         {0, 1, 4, 4, 4, 5, 6,  7,  8,  9},
1206         {0, 1, 3, 3, 4, 5, 6,  7,  8,  9},
1207         {0, 1, 5, 5, 5, 5, 6,  9,  9,  9}
1208 };
1209
1210 /* RACH Message3 related information */
1211 PUBLIC RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl = {
1212         {7,      6,  255,  255,  255,  7,   6,  255,  255,  255},
1213         {7,      6,  255,  255,    8,  7,   6,  255,  255,    8},
1214         {7,      6,  255,  9,      8,  7,   6,  255,    9,    8},
1215         {12,    11,  255,  255,  255,  7,   6,    6,    6,   13},
1216         {12,    11,  255,  255,    8,  7,   6,    6,   14,   13},
1217         {12,    11,  255,    9,    8,  7,   6,   15,   14,   13},
1218         {7,      6,  255,  255,  255,  7,   6,  255,  255,    8}
1219 };
1220
1221 /* ccpu00132341-DEL Removed rgSchTddRlsDlSubfrmTbl and used Kset table for 
1222  * releasing DL HARQs */
1223
1224 /* DwPTS Scheduling Changes Start */
1225 /* Provides the number of Cell Reference Signals in DwPTS
1226  * region per RB */
1227 PRIVATE U8  rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
1228            {4, 8,  16}, /* Spl Sf cfg 1,2,3,6,7,8 */
1229            {6, 12, 20}, /* Spl Sf cfg 4 */
1230 };
1231
1232 PRIVATE S8  rgSchCmnSplSfDeltaItbs[9] = RG_SCH_DWPTS_ITBS_ADJ;
1233 /* DwPTS Scheduling Changes End */
1234 #endif
1235
1236
1237 PRIVATE U32 rgSchCmnBsrTbl[64] = {
1238    0, 10, 12, 14, 17, 19, 22, 26,
1239    31, 36, 42, 49, 57, 67, 78, 91,
1240    107, 125, 146, 171, 200, 234, 274, 321,
1241    376, 440, 515, 603, 706, 826, 967, 1132,
1242    1326, 1552, 1817, 2127, 2490, 2915, 3413, 3995,
1243    4677, 5476, 6411, 7505, 8787, 10287, 12043, 14099,
1244    16507, 19325, 22624, 26487, 31009, 36304, 42502, 49759,
1245    58255, 68201, 79846, 93479, 109439, 128125, 150000, 220000
1246 };
1247
1248 PRIVATE U32 rgSchCmnExtBsrTbl[64] = {
1249    0, 10, 13, 16, 19, 23, 29, 35,
1250    43, 53, 65, 80, 98, 120, 147, 181,
1251    223, 274, 337, 414, 509, 625, 769, 945,
1252    1162, 1429, 1757, 2161, 2657, 3267, 4017, 4940,
1253    6074, 7469, 9185, 11294, 13888, 17077, 20999, 25822,
1254    31752, 39045, 48012, 59039, 72598, 89272, 109774, 134986,
1255    165989, 204111, 250990, 308634, 379519, 466683, 573866, 705666,
1256    867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
1257 };
1258
1259 PUBLIC U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
1260
1261 PUBLIC RgSchTbSzTbl rgTbSzTbl = {
1262  {
1263    {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},
1264    {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},
1265    {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},
1266    {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},
1267    {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},
1268    {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},
1269    {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},
1270    {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},
1271    {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},
1272    {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},
1273    {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},
1274    {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},
1275    {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},
1276    {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},
1277    {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},
1278    {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},
1279    {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},
1280    {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},
1281    {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},
1282    {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},
1283    {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},
1284    {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},
1285    {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},
1286    {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},
1287    {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},
1288    {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},
1289    {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}
1290  },
1291  {
1292    {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},
1293    {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},
1294    {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},
1295    {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},
1296    {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},
1297    {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},
1298    {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},
1299    {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},
1300    {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},
1301    {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},
1302    {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},
1303    {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},
1304    {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},
1305    {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},
1306    {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},
1307    {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},
1308    {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},
1309    {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},
1310    {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},
1311    {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},
1312    {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},
1313    {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},
1314    {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},
1315    {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},
1316    {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},
1317    {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},
1318    {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}
1319  }
1320 };
1321 RgSchUlIMcsTbl rgUlIMcsTbl = {
1322    {2, 0}, {2, 1}, {2, 2}, {2, 3}, {2, 4}, {2, 5},
1323    {2, 6}, {2, 7}, {2, 8}, {2, 9}, {2, 10},
1324    {4, 10}, {4, 11}, {4, 12}, {4, 13}, {4, 14},
1325    {4, 15}, {4, 16}, {4, 17}, {4, 18}, {4, 19},
1326    {6, 19}, {6, 20}, {6, 21}, {6, 22}, {6, 23},
1327    {6, 24}, {6, 25}, {6, 26}
1328 };
1329 RgSchUeCatTbl rgUeCatTbl = {
1330    /*Column1:Maximum number of bits of an UL-SCH 
1331              transport block transmitted within a TTI
1332              - maxUlBits
1333      Column2:Maximum number of bits of a DLSCH
1334              transport block received within a TTI 
1335              - maxDlBits
1336      Column3:Total number of soft channel bits 
1337              - maxSftChBits
1338      Column4:Support for 64QAM in UL 
1339              - ul64qamSup
1340      Column5:Maximum number of DL-SCH transport
1341              block bits received within a TTI
1342              - maxDlTbBits
1343      Column6:Maximum number of supported layers for 
1344              spatial multiplexing in DL 
1345              - maxTxLyrs*/
1346    {5160,  {10296,0},      250368,  FALSE, 10296,  1},
1347    {25456, {51024,0},      1237248, FALSE, 51024,  2},
1348    {51024, {75376,0},      1237248, FALSE, 102048, 2},
1349    {51024, {75376,0},      1827072, FALSE, 150752, 2},
1350    {75376, {149776,0},     3667200, TRUE,  299552, 4},
1351    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1352    {51024, {75376,149776}, 3654144, FALSE, 301504,  4},
1353    {149776,{299856,0},     35982720,TRUE,  2998560, 8}
1354 };
1355
1356 /* [ccpu00138532]-ADD-The below table stores the min HARQ RTT time
1357    in Downlink for TDD and FDD. Indices 0 to 6 map to tdd UL DL config 0-6. 
1358    Index 7 map to FDD */    
1359 U8 rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
1360 /* Number of CFI Switchover Index is equals to 7 TDD Indexes + 1 FDD index */
1361 U8 rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
1362
1363 /* EffTbl is calculated for single layer and two layers.
1364   * CqiToTbs is calculated for single layer and two layers */
1365 RgSchCmnTbSzEff rgSchCmnNorCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1366 RgSchCmnTbSzEff rgSchCmnNorCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1367 /* New variable to store UL effiency values for normal and extended CP*/
1368 RgSchCmnTbSzEff rgSchCmnNorUlEff[1],rgSchCmnExtUlEff[1];
1369 RgSchCmnCqiToTbs rgSchCmnNorCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1370 RgSchCmnCqiToTbs rgSchCmnNorCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnNorCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1371 RgSchCmnCqiToTbs *rgSchCmnCqiToTbs[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_CFI];
1372 RgSchCmnTbSzEff rgSchCmnExtCfi1Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2Eff[RGSCH_MAX_NUM_LYR_PERCW];
1373 RgSchCmnTbSzEff rgSchCmnExtCfi3Eff[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4Eff[RGSCH_MAX_NUM_LYR_PERCW];
1374 RgSchCmnCqiToTbs rgSchCmnExtCfi1CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi2CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1375 RgSchCmnCqiToTbs rgSchCmnExtCfi3CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW], rgSchCmnExtCfi4CqiToTbs[RGSCH_MAX_NUM_LYR_PERCW];
1376 /* Include CRS REs while calculating Efficiency */
1377 RgSchCmnTbSzEff *rgSchCmnEffTbl[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CP][RG_SCH_CMN_MAX_ANT_CONF][RG_SCH_CMN_MAX_CFI];
1378 RgSchCmnTbSzEff *rgSchCmnUlEffTbl[RG_SCH_CMN_MAX_CP];
1379 #ifdef LTE_TDD
1380 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3, 1};
1381 #else
1382 /* Added matrix 'rgRaPrmblToRaFrmTbl'for computation of RA sub-frames from RA preamble */
1383 RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl = {1, 2, 2, 3};
1384 #endif
1385
1386 EXTERN  RgUlSchdInits        rgSchUlSchdInits;
1387 EXTERN  RgDlSchdInits        rgSchDlSchdInits;
1388 EXTERN  RgDlfsSchdInits      rgSchDlfsSchdInits;
1389 #ifdef EMTC_ENABLE
1390 EXTERN  RgEmtcUlSchdInits        rgSchEmtcUlSchdInits;
1391 EXTERN  RgEmtcDlSchdInits        rgSchEmtcDlSchdInits;
1392 #endif
1393
1394 /* RACHO : start */
1395 PRIVATE S16 rgSCHCmnUeIdleExdThrsld ARGS((
1396 RgSchCellCb     *cell,
1397 RgSchUeCb       *ue
1398 ));
1399 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe ARGS((
1400 RgSchCellCb           *cell,
1401 U16                   rapId
1402 ));
1403 PRIVATE Void rgSCHCmnDelDedPreamble ARGS((
1404 RgSchCellCb           *cell,
1405 U8                    preambleId
1406 ));
1407 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe ARGS((
1408 RgSchCellCb           *cell,
1409 U16                   rapId,
1410 CmLteTimingInfo       timingInfo
1411 ));
1412 PRIVATE Void rgSCHCmnDelRachInfo ARGS((
1413 RgSchCellCb  *cell,
1414 RgSchUeCb    *ue
1415 ));
1416 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe ARGS((
1417 RgSchCellCb           *cell,
1418 RgSchUlSf             *sf,
1419 RgSchUeCb             *ue,
1420 U8                    maxRb
1421 ));
1422 PRIVATE Void rgSCHCmnHdlHoPo ARGS((
1423 RgSchCellCb           *cell,
1424 CmLListCp             *raRspLst,
1425 RgSchRaReqInfo        *raReq
1426 ));
1427 PRIVATE Void rgSCHCmnAllocPoHoGrnt ARGS((
1428 RgSchCellCb           *cell,
1429 CmLListCp             *raRspLst,
1430 RgSchUeCb             *ue,
1431 RgSchRaReqInfo        *raReq
1432 ));
1433 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf ARGS((
1434 RgSchCellCb *cell,
1435 RgSchUeCb   *ue,
1436 RgSchPdcch  *pdcc,
1437 U8          rapId,
1438 U8          prachMskIdx
1439 ));
1440 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
1441 RgSchCellCb                *cell,
1442 RgSchUeCb                  *ue
1443 ));
1444 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ ARGS((
1445 RgSchCellCb                *cell,
1446 RgSchUeCb                  *ue
1447 ));
1448 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx ARGS((
1449 RgSchCellCb  *cell
1450 ));
1451 PRIVATE Void rgSCHCmnUpdRachParam ARGS((
1452 RgSchCellCb  *cell
1453 ));
1454 PRIVATE S16 rgSCHCmnAllocPOParam ARGS((
1455 RgSchCellCb  *cell,
1456 RgSchDlSf    *dlSf,
1457 RgSchUeCb    *ue,
1458 RgSchPdcch   **pdcch,
1459 U8           *rapId,
1460 U8           *prachMskIdx
1461 ));
1462 PRIVATE Void rgSCHCmnGenPdcchOrder ARGS((
1463 RgSchCellCb  *cell,
1464 RgSchDlSf    *dlSf
1465 ));
1466 PRIVATE Void rgSCHCmnCfgRachDedPrm ARGS((
1467 RgSchCellCb   *cell
1468 ));
1469 /* RACHO : end */
1470
1471 PRIVATE Void rgSCHCmnHdlUlInactUes ARGS((
1472 RgSchCellCb  *cell
1473 ));
1474 PRIVATE Void rgSCHCmnHdlDlInactUes ARGS((
1475 RgSchCellCb  *cell
1476 ));
1477 PRIVATE Void rgSCHCmnUlInit ARGS((Void
1478 ));
1479 PRIVATE Void rgSCHCmnDlInit ARGS((Void
1480 ));
1481 PRIVATE Void rgSCHCmnInitDlRbAllocInfo ARGS((
1482 RgSchCmnDlRbAllocInfo  *allocInfo
1483 ));
1484 PRIVATE Void rgSCHCmnUpdUlCompEffBsr ARGS((
1485 RgSchUeCb *ue
1486 ));
1487 #if RG_UNUSED
1488 PRIVATE Void rgSCHCmnUlSetAllUnSched  ARGS((
1489 RgSchCmnUlRbAllocInfo *allocInfo
1490 ));
1491 PRIVATE Void rgSCHCmnUlUpdSf ARGS((
1492          RgSchCellCb           *cell,
1493          RgSchCmnUlRbAllocInfo *allocInfo,
1494          RgSchUlSf     *sf
1495          ));
1496 PRIVATE Void rgSCHCmnUlHndlAllocRetx ARGS((
1497          RgSchCellCb           *cell,
1498          RgSchCmnUlRbAllocInfo *allocInfo,
1499          RgSchUlSf     *sf,
1500          RgSchUlAlloc  *alloc
1501          ));
1502 #endif
1503 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch ARGS((
1504 RgSchCellCb  *cell,
1505 RgSchDlSf    *dlSf
1506 ));
1507 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch ARGS((
1508 RgSchCellCb  *cell,
1509 RgSchUlSf    *ulSf
1510 ));
1511 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ ARGS((
1512 RgSchCellCb     *cell,
1513 RgSchUeCb       *ue
1514 ));
1515 PRIVATE S16 rgSCHCmnTmrExpiry ARGS((
1516 PTR cb,               /* Pointer to timer control block */
1517 S16 tmrEvnt           /* Timer Event */
1518 ));
1519 PRIVATE S16 rgSCHCmnTmrProc ARGS((
1520 RgSchCellCb *cell
1521 ));
1522 PRIVATE Void rgSCHCmnAddUeToRefreshQ ARGS((
1523 RgSchCellCb     *cell,
1524 RgSchUeCb       *ue,
1525 U32             wait
1526 ));
1527 PRIVATE Void rgSCHCmnDlCcchRetx ARGS((
1528 RgSchCellCb             *cell,
1529 RgSchCmnDlRbAllocInfo   *allocInfo
1530 ));
1531 PRIVATE Void rgSCHCmnUpdUeMimoInfo ARGS((
1532 RgrUeCfg     *ueCfg,
1533 RgSchCmnDlUe *ueDl,
1534 RgSchCellCb  *cell,
1535 RgSchCmnCell *cellSchd
1536 ));
1537 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo ARGS((
1538 RgSchCellCb   *cell,
1539 RgSchUeCb     *ue,
1540 RgSchCmnUlUe  *ueUl,
1541 RgSchCmnUe    *ueSchCmn,
1542 RgSchCmnCell  *cellSchd,
1543 Bool          isEcp 
1544 ));
1545 #ifdef RGR_V1
1546 PRIVATE Void rgSCHCmnDlCcchSduRetx ARGS((
1547 RgSchCellCb             *cell,
1548 RgSchCmnDlRbAllocInfo   *allocInfo
1549 ));
1550 PRIVATE Void rgSCHCmnDlCcchSduTx ARGS((
1551 RgSchCellCb             *cell,
1552 RgSchCmnDlRbAllocInfo   *allocInfo
1553 ));
1554 PRIVATE S16 rgSCHCmnCcchSduAlloc ARGS((
1555 RgSchCellCb                *cell,
1556 RgSchUeCb                  *ueCb,
1557 RgSchCmnDlRbAllocInfo      *allocInfo
1558 ));
1559 PRIVATE S16 rgSCHCmnCcchSduDedAlloc ARGS((
1560 RgSchCellCb                *cell,
1561 RgSchUeCb                  *ueCb
1562 ));
1563 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc ARGS((
1564 RgSchCellCb           *cell,
1565 RgSchUeCb             *ueCb,
1566 RgSchDlSf             *dlSf
1567 ));
1568 #endif
1569 PRIVATE Void rgSCHCmnInitVars ARGS((
1570          RgSchCellCb *cell
1571          ));
1572
1573 /*ccpu00117180 - DEL - Moved rgSCHCmnUpdVars to .x as its access is now PUBLIC */
1574 PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
1575          RgSchCellCb           *cell,
1576          RgSchUlSf             *sf,
1577          U32                   count,
1578          CmLListCp             *reqLst,
1579          CmLListCp             *schdLst,
1580          CmLListCp             *nonSchdLst,
1581          Bool                  isNewTx
1582          ));
1583 PRIVATE S16 rgSCHCmnUlRbAllocForUe ARGS((
1584          RgSchCellCb           *cell,
1585          RgSchUlSf             *sf,
1586          RgSchUeCb             *ue,
1587          U8                    maxRb,
1588          RgSchUlHole           *hole
1589          ));
1590 PRIVATE Void rgSCHCmnMsg3GrntReq ARGS((
1591          RgSchCellCb     *cell,
1592          CmLteRnti       rnti,
1593          Bool            preamGrpA,
1594          RgSchUlHqProcCb *hqProc,
1595          RgSchUlAlloc    **ulAllocRef,
1596          U8              *hqProcIdRef
1597          ));
1598 PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
1599 RgSchCellCb             *cell
1600 ));
1601 PRIVATE Void rgSCHCmnDlCcchTx ARGS((
1602 RgSchCellCb             *cell,
1603 RgSchCmnDlRbAllocInfo   *allocInfo
1604 ));
1605 PRIVATE Void rgSCHCmnDlBcchPcch ARGS((
1606 RgSchCellCb             *cell,
1607 RgSchCmnDlRbAllocInfo   *allocInfo,
1608 RgInfSfAlloc            *subfrmAlloc
1609 ));
1610 PUBLIC Bool rgSCHCmnChkInWin ARGS((
1611 CmLteTimingInfo   frm,
1612 CmLteTimingInfo   start,
1613 CmLteTimingInfo   end
1614 ));
1615 PUBLIC Bool rgSCHCmnChkPastWin ARGS((
1616 CmLteTimingInfo   frm,
1617 CmLteTimingInfo   end
1618 ));
1619 PRIVATE Void rgSCHCmnClcAlloc ARGS((
1620 RgSchCellCb             *cell,
1621 RgSchDlSf               *sf,
1622 RgSchClcDlLcCb          *lch,
1623 U16                     rnti,
1624 RgSchCmnDlRbAllocInfo   *allocInfo
1625 ));
1626 #ifndef LTEMAC_SPS
1627 PRIVATE Void rgSCHCmnClcRbAlloc ARGS((
1628 RgSchCellCb             *cell,
1629 U32                     bo,
1630 U8                      cqi,
1631 U8                      *rb,
1632 U32                     *tbs,
1633 U8                      *mcs,
1634 RgSchDlSf               *sf 
1635 ));
1636 #endif
1637
1638 PRIVATE S16 rgSCHCmnMsg4Alloc ARGS((
1639 RgSchCellCb                *cell,
1640 RgSchRaCb                  *raCb,
1641 RgSchCmnDlRbAllocInfo      *allocInfo
1642 ));
1643 PRIVATE S16 rgSCHCmnMsg4DedAlloc ARGS((
1644 RgSchCellCb                *cell,
1645 RgSchRaCb                  *raCb
1646 ));
1647 PRIVATE Void rgSCHCmnDlRaRsp ARGS((
1648 RgSchCellCb                *cell,
1649 RgSchCmnDlRbAllocInfo      *allocInfo
1650 ));
1651 PRIVATE S16 rgSCHCmnRaRspAlloc ARGS((
1652 RgSchCellCb             *cell,
1653 RgSchDlSf               *subFrm,
1654 U16                     rntiIdx,
1655 U16                     rarnti,
1656 U8                      noRaRnti,
1657 RgSchCmnDlRbAllocInfo   *allocInfo
1658 ));
1659 PRIVATE Void rgSCHCmnUlUeDelAllocs ARGS((
1660 RgSchCellCb  *cell,
1661 RgSchUeCb   *ue
1662 ));
1663 PRIVATE Void rgSCHCmnDlSetUeAllocLmt ARGS((
1664 RgSchCellCb   *cell,
1665 RgSchCmnDlUe  *ueDl,
1666 Bool          isEmtcUe
1667 ));
1668 PRIVATE S16 rgSCHCmnDlRgrCellCfg ARGS((
1669 RgSchCellCb    *cell,
1670 RgrCellCfg     *cfg,
1671 RgSchErrInfo   *err
1672 ));
1673 PRIVATE Void rgSCHCmnUlAdapRetx ARGS((
1674 RgSchUlAlloc    *alloc,
1675 RgSchUlHqProcCb *proc
1676 ));
1677 PRIVATE Void rgSCHCmnUlUpdAllocRetx ARGS((
1678 RgSchCellCb    *cell,
1679 RgSchUlAlloc   *alloc
1680 ));
1681 PRIVATE Void rgSCHCmnUlSfReTxAllocs ARGS((
1682 RgSchCellCb *cell,
1683 RgSchUlSf   *sf
1684 ));
1685 /* Fix: syed Adaptive Msg3 Retx crash. */
1686 #ifdef TFU_UPGRADE
1687 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1688 ((
1689 RgSchCellCb *cell,
1690 RgSchUeCb    *ue,
1691 RgrUeRecfg   *ueRecfg,
1692 U8 numTxPorts
1693 ));
1694 #else
1695 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
1696 ((
1697 RgSchCellCb *cell,
1698 RgSchUeCb    *ue,
1699 RgrUeRecfg   *ueRecfg
1700 ));
1701 #endif
1702
1703
1704 /*
1705  * DL RB allocation specific functions
1706  */
1707
1708 PRIVATE Void rgSCHCmnDlRbAlloc ARGS((
1709 RgSchCellCb           *cell,
1710 RgSchCmnDlRbAllocInfo *allocInfo
1711 ));
1712 PRIVATE Void rgSCHCmnNonDlfsRbAlloc ARGS((
1713 RgSchCellCb           *cell,
1714 RgSchCmnDlRbAllocInfo *allocInfo
1715 ));
1716 PRIVATE S16 rgSCHCmnNonDlfsCmnRbAlloc ARGS((
1717 RgSchCellCb           *cell,
1718 RgSchDlRbAlloc        *cmnAllocInfo));
1719
1720 #ifndef LTE_TDD
1721 PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
1722 RgSchCellCb           *cell,
1723 RgSchDlRbAlloc        *cmnAllocInfo,
1724 U8                    pbchSsRsSym,
1725 Bool                  isBcchPcch
1726 ));
1727 /* Added function to adjust TBSize*/
1728 PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
1729 RgSchDlRbAlloc        *allocInfo,
1730 U8                    numOvrlapgPbchRb,
1731 U8                    pbchSsRsSym,
1732 U8                    idx,
1733 U32                   bytesReq
1734 ));
1735
1736 /* Added function to find num of overlapping PBCH rb*/
1737 PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs ARGS((
1738 RgSchCellCb           *cell,
1739 RgSchDlSf             *dlSf,
1740 RgSchDlRbAlloc        *allocInfo,
1741 U8                    *numOvrlapgPbchRb
1742 ));
1743
1744 PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl ARGS((
1745 RgSchCellCb           *cell,
1746 RgSchDlSf             *dlSf,
1747 RgSchDlRbAlloc        *allocInfo
1748 ));
1749 #ifdef DEBUGP
1750 #ifdef UNUSED_FUNC
1751 PRIVATE Void rgSCHCmnFindCodeRate ARGS((
1752 RgSchCellCb           *cell,
1753 RgSchDlSf             *dlSf,
1754 RgSchDlRbAlloc        *allocInfo,
1755 U8                    idx
1756 ));
1757 #endif
1758 #endif
1759 #endif
1760 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
1761 RgSchCellCb           *cell,
1762 RgSchCmnMsg4RbAlloc   *msg4AllocInfo,
1763 U8                    isRetx
1764 ));
1765 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
1766 RgSchCellCb           *cell,
1767 RgSchRaCb             *raCb,
1768 RgSchDlSf             *dlSf
1769 ));
1770
1771 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc ARGS((
1772 RgSchCellCb           *cell,
1773 RgSchUeCb             *ue,
1774 RgSchDlSf             *dlSf,
1775 U8                    *isDlBwAvail
1776 ));
1777 #ifndef LTEMAC_SPS
1778 PRIVATE U32 rgSCHCmnCalcRiv ARGS(( U8 bw,
1779          U8           rbStart,
1780          U8           numRb));
1781 #endif
1782
1783 #ifdef LTE_TDD
1784 PRIVATE Void rgSCHCmnUpdHqAndDai ARGS((
1785 RgSchDlHqProcCb   *hqP,
1786 RgSchDlSf         *subFrm,
1787 RgSchDlHqTbCb     *tbCb,
1788 U8                tbAllocIdx
1789 ));
1790 PRIVATE S16 rgSCHCmnUlCalcAvailBw ARGS((
1791 RgSchCellCb *cell,
1792 RgrCellCfg  *cellCfg,
1793 U8          cfi,
1794 U8          *rbStartRef,
1795 U8          *bwAvailRef
1796 ));
1797 PRIVATE S16 rgSCHCmnDlKdashUlAscInit ARGS((
1798 RgSchCellCb *cell
1799 ));
1800 PRIVATE S16 rgSCHCmnDlANFdbkInit ARGS((
1801 RgSchCellCb *cell
1802 ));
1803 PRIVATE S16 rgSCHCmnDlNpValInit ARGS((
1804 RgSchCellCb *cell
1805 ));
1806 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst ARGS((
1807 RgSchCellCb *cell
1808 ));
1809 PRIVATE S16 rgSCHCmnDlCpyRachInfo ARGS((
1810 RgSchCellCb        *cell,
1811 RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
1812 U8                 raArrSz
1813 ));
1814 PRIVATE S16 rgSCHCmnDlRachInfoInit ARGS((
1815 RgSchCellCb *cell
1816 ));
1817 PRIVATE S16 rgSCHCmnDlPhichOffsetInit ARGS((
1818 RgSchCellCb *cell
1819 ));
1820 #endif
1821 #ifdef TFU_UPGRADE
1822 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt ARGS
1823 ((
1824  RgSchCellCb          *cell,
1825  RgSchUeCb            *ue,
1826  U8                          wideCqi
1827  ));
1828  PRIVATE RgSchCmnRank rgSCHCmnComputeRank ARGS
1829 ((
1830  RgrTxMode    txMode,
1831  U32          *pmiBitMap,
1832  U8           numTxPorts
1833  ));
1834
1835  PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
1836 ((
1837  U32 *pmiBitMap
1838  ));
1839
1840   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
1841 ((
1842  U32 *pmiBitMap
1843  ));
1844
1845   PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
1846 ((
1847  U32 *pmiBitMap
1848  ));
1849
1850   PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
1851 ((
1852  U32 *pmiBitMap
1853  ));
1854
1855  PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr ARGS
1856 ((
1857  RgSchCellCb        *cell,
1858  TfuSrsRpt        *srsRpt
1859  ));
1860 #endif
1861
1862 /* comcodsepa : start */
1863 \f
1864 /**
1865  * @brief This function computes efficiency and stores in a table.
1866  *
1867  * @details
1868  *
1869  *     Function: rgSCHCmnCompEff
1870  *     Purpose:  this function computes the efficiency as number of
1871  *               bytes per 1024 symbols. The CFI table is also filled
1872  *               with the same information such that comparison is valid
1873  *
1874  *     Invoked by: Scheduler
1875  *
1876  *  @param[in]  U8            noPdcchSym
1877  *  @param[in]  U8            cpType
1878  *  @param[in]  U8            txAntIdx
1879  *  @param[in]  RgSchCmnTbSzEff* effTbl
1880  *  @return  Void
1881  *
1882  **/
1883 #ifdef ANSI
1884 PRIVATE Void rgSCHCmnCompEff
1885 (
1886 U8                    noPdcchSym,
1887 U8                    cpType,
1888 U8                    txAntIdx,
1889 RgSchCmnTbSzEff       *effTbl
1890 )
1891 #else
1892 PRIVATE Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
1893 U8                    noPdcchSym;
1894 U8                    cpType;
1895 U8                    txAntIdx;
1896 RgSchCmnTbSzEff       *effTbl;
1897 #endif
1898 {
1899    U8               noResPerRb;
1900    U8               noSymPerRb;
1901    U8               resOfCrs; /* Effective REs occupied by CRS */
1902    U8               i, j;
1903
1904    TRC2(rgSCHCmnCompEff);
1905
1906    switch (cpType)
1907    {
1908       case RG_SCH_CMN_NOR_CP:
1909          noSymPerRb = 14;
1910          break;
1911       case RG_SCH_CMN_EXT_CP:
1912          noSymPerRb = 12;
1913          break;
1914       default:
1915          /* Generate a log error. This case should never be executed */
1916          RETVOID;
1917    }
1918
1919    /* Depending on the Tx Antenna Index, deduct the
1920     * Resource elements for the CRS */
1921    switch (txAntIdx)
1922    {
1923       case 0:
1924          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
1925          break;
1926       case 1:
1927          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
1928          break;
1929       case 2:
1930          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
1931          break;
1932       default:
1933          /* Generate a log error. This case should never be executed */
1934          RETVOID;
1935    }
1936    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
1937    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
1938    {
1939       (*effTbl)[i] = 0;
1940       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
1941       {
1942          /* This line computes the coding efficiency per 1024 REs */
1943          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
1944       }
1945       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
1946    }
1947    RETVOID;
1948 }
1949 /**
1950  * @brief This function computes efficiency and stores in a table.
1951  *
1952  * @details
1953  *
1954  *     Function: rgSCHCmnCompUlEff
1955  *     Purpose:  this function computes the efficiency as number of
1956  *               bytes per 1024 symbols. The CFI table is also filled
1957  *               with the same information such that comparison is valid
1958  *
1959  *     Invoked by: Scheduler
1960  *
1961  *  @param[in]  U8            noUlRsSym
1962  *  @param[in]  U8            cpType
1963  *  @param[in]  U8            txAntIdx
1964  *  @param[in]  RgSchCmnTbSzEff* effTbl
1965  *  @return  Void
1966  *
1967  **/
1968 #ifdef ANSI
1969 PRIVATE Void rgSCHCmnCompUlEff
1970 (
1971 U8                    noUlRsSym,
1972 U8                    cpType,
1973 RgSchCmnTbSzEff       *effTbl
1974 )
1975 #else
1976 PRIVATE Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
1977 U8                    noUlRsSym;
1978 U8                    cpType;
1979 RgSchCmnTbSzEff       *effTbl;
1980 #endif
1981 {
1982    U8               noResPerRb;
1983    U8               noSymPerRb;
1984    U8               i, j;
1985
1986    TRC2(rgSCHCmnCompUlEff);
1987
1988    switch (cpType)
1989    {
1990       case RG_SCH_CMN_NOR_CP:
1991          noSymPerRb = 14;
1992          break;
1993       case RG_SCH_CMN_EXT_CP:
1994          noSymPerRb = 12;
1995          break;
1996       default:
1997          /* Generate a log error. This case should never be executed */
1998          RETVOID;
1999    }
2000
2001    noResPerRb = ((noSymPerRb - noUlRsSym) * RB_SCH_CMN_NUM_SCS_PER_RB);
2002    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2003    {
2004       (*effTbl)[i] = 0;
2005       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2006       {
2007          /* This line computes the coding efficiency per 1024 REs */
2008          (*effTbl)[i] += (rgTbSzTbl[0][i][j] * 1024) / (noResPerRb * (j+1));
2009       }
2010       (*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
2011    }
2012    RETVOID;
2013 }
2014
2015 /**
2016  * @brief This function computes efficiency for 2 layers and stores in a table.
2017  *
2018  * @details
2019  *
2020  *     Function: rgSCHCmn2LyrCompEff
2021  *     Purpose:  this function computes the efficiency as number of
2022  *               bytes per 1024 symbols. The CFI table is also filled
2023  *               with the same information such that comparison is valid
2024  *
2025  *     Invoked by: Scheduler
2026  *
2027  *  @param[in]  U8            noPdcchSym
2028  *  @param[in]  U8            cpType
2029  *  @param[in]  U8            txAntIdx
2030  *  @param[in]  RgSchCmnTbSzEff* effTbl2Lyr
2031  *  @return  Void
2032  *
2033  **/
2034 #ifdef ANSI
2035 PRIVATE Void rgSCHCmn2LyrCompEff
2036 (
2037 U8                    noPdcchSym,
2038 U8                    cpType,
2039 U8                    txAntIdx,
2040 RgSchCmnTbSzEff       *effTbl2Lyr
2041 )
2042 #else
2043 PRIVATE Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
2044 U8                    noPdcchSym;
2045 U8                    cpType;
2046 U8                    txAntIdx;
2047 RgSchCmnTbSzEff       *effTbl2Lyr;
2048 #endif
2049 {
2050    U8               noResPerRb;
2051    U8               noSymPerRb;
2052    U8               resOfCrs; /* Effective REs occupied by CRS */
2053    U8               i, j;
2054
2055    TRC2(rgSCHCmn2LyrCompEff);
2056
2057    switch (cpType)
2058    {
2059       case RG_SCH_CMN_NOR_CP:
2060          noSymPerRb = 14;
2061          break;
2062       case RG_SCH_CMN_EXT_CP:
2063          noSymPerRb = 12;
2064          break;
2065       default:
2066          /* Generate a log error. This case should never be executed */
2067          RETVOID;
2068    }
2069
2070    /* Depending on the Tx Antenna Index, deduct the
2071     * Resource elements for the CRS */
2072    switch (txAntIdx)
2073    {
2074       case 0:
2075          resOfCrs = RG_SCH_CMN_EFF_CRS_ONE_ANT_PORT;
2076          break;
2077       case 1:
2078          resOfCrs = RG_SCH_CMN_EFF_CRS_TWO_ANT_PORT;
2079          break;
2080       case 2:
2081          resOfCrs = RG_SCH_CMN_EFF_CRS_FOUR_ANT_PORT;
2082          break;
2083       default:
2084          /* Generate a log error. This case should never be executed */
2085          RETVOID;
2086    }
2087
2088    noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
2089    for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
2090    {
2091       (*effTbl2Lyr)[i] = 0;
2092       for (j = 0; j < RG_SCH_CMN_NUM_RBS; j++)
2093       {
2094          /* This line computes the coding efficiency per 1024 REs */
2095          (*effTbl2Lyr)[i] += (rgTbSzTbl[1][i][j] * 1024) / (noResPerRb * (j+1));
2096       }
2097       (*effTbl2Lyr)[i] /= RG_SCH_CMN_NUM_RBS;
2098    }
2099    RETVOID;
2100 }
2101
2102 \f
2103 /**
2104  * @brief This function initializes the rgSchCmnDciFrmtSizes table.
2105  *
2106  * @details
2107  *
2108  *     Function: rgSCHCmnGetDciFrmtSizes
2109  *     Purpose:  This function determines the sizes of all
2110  *               the available DCI Formats. The order of
2111  *               bits addition for each format is inaccordance
2112  *               with the specs.
2113  *     Invoked by: rgSCHCmnRgrCellCfg
2114  *
2115  *  @return  Void
2116  *
2117  **/
2118 #ifdef ANSI
2119 PRIVATE Void rgSCHCmnGetDciFrmtSizes
2120 (
2121 RgSchCellCb *cell
2122 )
2123 #else
2124 PRIVATE Void rgSCHCmnGetDciFrmtSizes(cell)
2125 RgSchCellCb *cell;
2126 #endif
2127 {
2128
2129    TRC2(rgSCHCmnGetDciFrmtSizes);
2130
2131    /* DCI Format 0 size determination */
2132    rgSchCmnDciFrmtSizes[0] = 1 +
2133                              1 +
2134                              rgSCHUtlLog32bitNbase2((cell->bwCfg.ulTotalBw * \
2135                              (cell->bwCfg.ulTotalBw + 1))/2) +
2136                              5 +
2137                              1 +
2138                              2 +
2139                              3 +
2140 #ifdef LTE_TDD
2141                              2 +
2142                              2 +
2143 #endif
2144                              1;
2145    /* DCI Format 1 size determination */
2146    rgSchCmnDciFrmtSizes[1] = 1 +
2147    RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2148                              5 +
2149 #ifndef LTE_TDD
2150                              3 +
2151 #else
2152                              4 + 2 + /* HqProc Id and DAI */
2153 #endif
2154                              1 +
2155                              2 +
2156                              2;
2157
2158    /* DCI Format 1A size determination */
2159    rgSchCmnDciFrmtSizes[2] = 1 + /* Flag for format0/format1a differentiation */
2160                1 + /* Localized/distributed VRB assignment flag */
2161                5 + /* For mcs */
2162 #ifndef LTE_TDD
2163                3 + /* Harq process Id */
2164 #else
2165                4 + /* Harq process Id */
2166                2 + /* UL Index or DAI */
2167 #endif
2168                1 + /* New Data Indicator */
2169                2 + /* For RV */
2170                2 + /* For tpc */
2171                1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2172                    (cell->bwCfg.dlTotalBw + 1))/2);
2173                /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
2174                   Since VRB is local */
2175
2176    /* DCI Format 1B size determination */
2177    rgSchCmnDciFrmtSizes[3] = 1 +
2178                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2179                              (cell->bwCfg.dlTotalBw + 1))/2) +
2180                              5 +
2181                              3 +
2182 #ifdef LTE_TDD
2183                              1 + /* HqP */
2184                              2 + /* Dai */
2185 #endif
2186                              1 +
2187                              2 +
2188                              2 +
2189                              ((cell->numTxAntPorts == 4)? 4:2) +
2190                              1;
2191
2192    /* DCI Format 1C size determination */
2193    /* Approximation: NDLVrbGap1 ~= Nprb for DL */
2194    rgSchCmnDciFrmtSizes[4] = (cell->bwCfg.dlTotalBw < 50)? 0:1 +
2195                              (cell->bwCfg.dlTotalBw < 50)?
2196                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/2 * \
2197                                 (cell->bwCfg.dlTotalBw/2 + 1))/2)) :
2198                              (rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw/4 * \
2199                                 (cell->bwCfg.dlTotalBw/4 + 1))/2)) +
2200                              5;
2201
2202    /* DCI Format 1D size determination */
2203    rgSchCmnDciFrmtSizes[5] = 1 +
2204                              rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
2205                              (cell->bwCfg.dlTotalBw + 1))/2) +
2206                              5 +
2207                              3 +
2208 #ifdef LTE_TDD
2209                              1 + 2 +
2210 #endif
2211                              1 +
2212                              2 +
2213                              2 +
2214                              ((cell->numTxAntPorts == 4)? 4:2) +
2215                              1;
2216
2217    /* DCI Format 2 size determination */
2218    rgSchCmnDciFrmtSizes[6] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2219                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2220                              2 +
2221 #ifdef LTE_TDD
2222                              2 + 1 +
2223 #endif
2224                              3 +
2225                              1 +
2226                              (5 + 1 + 2)*2 +
2227                              ((cell->numTxAntPorts == 4)? 6:3);
2228
2229    /* DCI Format 2A size determination */
2230    rgSchCmnDciFrmtSizes[7] = ((cell->bwCfg.dlTotalBw < 10)?0:1) +
2231                              RGSCH_CEIL(cell->bwCfg.dlTotalBw, cell->rbgSize) +
2232                              2 +
2233 #ifdef LTE_TDD
2234                              2 + 1 +
2235 #endif
2236                              3 +
2237                              1 +
2238                              (5 + 1 + 2)*2 +
2239                              ((cell->numTxAntPorts == 4)? 2:0);
2240
2241    /* DCI Format 3 size determination */
2242    rgSchCmnDciFrmtSizes[8] = rgSchCmnDciFrmtSizes[0];
2243
2244    /* DCI Format 3A size determination */
2245    rgSchCmnDciFrmtSizes[9] = rgSchCmnDciFrmtSizes[0];
2246
2247    RETVOID;
2248 }
2249
2250
2251 /**
2252  * @brief This function initializes the cmnCell->dciAggrLvl table.
2253  *
2254  * @details
2255  *
2256  *     Function: rgSCHCmnGetCqiDciFrmt2AggrLvl
2257  *     Purpose:  This function determines the Aggregation level
2258  *               for each CQI level against each DCI format.
2259  *     Invoked by: rgSCHCmnRgrCellCfg
2260  *
2261  *  @return  Void
2262  *
2263  **/
2264 #ifdef ANSI
2265 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl
2266 (
2267 RgSchCellCb *cell
2268 )
2269 #else
2270 PRIVATE Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
2271 RgSchCellCb *cell;
2272 #endif
2273 {
2274    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
2275    U8            i;
2276    U8            j;
2277
2278    TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
2279
2280    for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
2281    {
2282       for (j = 0; j < 10; j++)
2283       {
2284          U32 pdcchBits; /* Actual number of phy bits needed for a given DCI Format
2285                * for a given CQI Level */
2286          pdcchBits = (rgSchCmnDciFrmtSizes[j] * 1024)/rgSchCmnCqiPdcchEff[i];
2287                         /* V5G_211 : 6.6 */
2288          if (pdcchBits < 192)
2289          {
2290              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL2;
2291              continue;
2292          }
2293          if (pdcchBits < 384)
2294          {
2295              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL4;
2296              continue;
2297          }
2298          if (pdcchBits < 768)
2299          {
2300              cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL8;
2301              continue;
2302          }
2303          cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL16;
2304       }
2305    }
2306    RETVOID;
2307 }
2308 \f
2309 /**
2310  * @brief This function initializes all the data for the scheduler.
2311  *
2312  * @details
2313  *
2314  *     Function: rgSCHCmnDlInit
2315  *     Purpose:  This function initializes the following information:
2316  *               1. Efficiency table
2317  *               2. CQI to table index - It is one row for upto 3 RBs
2318  *                  and another row for greater than 3 RBs
2319  *                  currently extended prefix is compiled out.
2320  *     Invoked by: MAC intialization code..may be ActvInit
2321  *
2322  *  @return  Void
2323  *
2324  **/
2325 #ifdef ANSI
2326 PRIVATE Void rgSCHCmnDlInit
2327 (
2328 )
2329 #else
2330 PRIVATE Void rgSCHCmnDlInit()
2331 #endif
2332 {
2333    U8                   i;
2334    S16                  j;
2335    S16                  k;
2336    U8                   idx;
2337    RgSchCmnTbSzEff      *effTbl;
2338    RgSchCmnCqiToTbs     *tbsTbl;
2339
2340    TRC2(rgSCHCmnDlInit);
2341
2342    /* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
2343    /* Init Efficiency table for normal cyclic prefix */
2344    /*Initialize Efficiency table for Layer Index 0 */
2345    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2346    /*Initialize Efficiency table for each of the CFI indices. The
2347     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2348    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[0];
2349    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[0];
2350    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[0];
2351    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[0];
2352    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2353    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[0];
2354    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[0];
2355    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[0];
2356    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[0];
2357    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2358    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[0];
2359    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[0];
2360    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[0];
2361    rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[0];
2362
2363    /*Initialize CQI to TBS table for Layer Index 0 for Normal CP */
2364    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[0];
2365    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[0];
2366    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[0];
2367    rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[0];
2368
2369    /*Intialize Efficency table for Layer Index 1 */
2370    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2371    /*Initialize Efficiency table for each of the CFI indices. The
2372     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2373    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][0] = &rgSchCmnNorCfi1Eff[1];
2374    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][1] = &rgSchCmnNorCfi2Eff[1];
2375    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][2] = &rgSchCmnNorCfi3Eff[1];
2376    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][0][3] = &rgSchCmnNorCfi4Eff[1];
2377    /*Initialize Efficiency table for Tx Antenna Port Index 1 */
2378    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][0] = &rgSchCmnNorCfi1Eff[1];
2379    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][1] = &rgSchCmnNorCfi2Eff[1];
2380    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][2] = &rgSchCmnNorCfi3Eff[1];
2381    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][1][3] = &rgSchCmnNorCfi4Eff[1];
2382    /*Initialize Efficiency table for Tx Antenna Port Index 2 */
2383    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][0] = &rgSchCmnNorCfi1Eff[1];
2384    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][1] = &rgSchCmnNorCfi2Eff[1];
2385    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][2] = &rgSchCmnNorCfi3Eff[1];
2386    rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][2][3] = &rgSchCmnNorCfi4Eff[1];
2387
2388    /*Initialize CQI to TBS table for Layer Index 1 for Normal CP */
2389    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][0] = &rgSchCmnNorCfi1CqiToTbs[1];
2390    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][1] = &rgSchCmnNorCfi2CqiToTbs[1];
2391    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][2] = &rgSchCmnNorCfi3CqiToTbs[1];
2392    rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][3] = &rgSchCmnNorCfi4CqiToTbs[1];
2393
2394    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2395    {
2396       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2397       {
2398          /* EfficiencyTbl calculation incase of 2 layers for normal CP  */
2399          rgSCHCmnCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
2400                rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i]);
2401          rgSCHCmn2LyrCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
2402                rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i]);
2403       }
2404    }
2405
2406    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2407    {
2408       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2409       {
2410          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i];
2411          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_NOR_CP][i];
2412          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2413                (j >= 0) && (k > 0); --j)
2414          {
2415             /* ADD CQI to MCS mapping correction
2416             * single dimensional array is replaced by 2 dimensions for different CFI*/
2417             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2418             {
2419                (*tbsTbl)[k--] = (U8)j;
2420             }
2421          }
2422          for (; k > 0; --k)
2423          {
2424             (*tbsTbl)[k] = 0;
2425          }
2426          /* effTbl,tbsTbl calculation incase of 2 layers for normal CP */
2427          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i];
2428          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_NOR_CP][i];
2429          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2430                (j >= 0) && (k > 0); --j)
2431          {
2432             /* ADD CQI to MCS mapping correction
2433             * single dimensional array is replaced by 2 dimensions for different CFI*/
2434             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2435             {
2436                (*tbsTbl)[k--] = (U8)j;
2437             }
2438          }
2439          for (; k > 0; --k)
2440          {
2441             (*tbsTbl)[k] = 0;
2442          }
2443       }
2444    }
2445
2446    /* Efficiency Table for Extended CP */
2447    /*Initialize Efficiency table for Layer Index 0 */
2448    /*Initialize Efficiency table for Tx Antenna Port Index 0 */
2449    /*Initialize Efficiency table for each of the CFI indices. The
2450     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2451    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[0];
2452    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[0];
2453    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[0];
2454    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[0];
2455    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2456    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[0];
2457    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[0];
2458    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[0];
2459    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[0];
2460    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2461    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[0];
2462    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[0];
2463    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[0];
2464    rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[0];
2465
2466    /*Initialize CQI to TBS table for Layer Index 0 for Extended CP */
2467    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[0];
2468    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[0];
2469    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[0];
2470    rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[0];
2471
2472    /*Initialize Efficiency table for Layer Index 1 */
2473    /*Initialize Efficiency table for each of the CFI indices. The
2474     * 4th Dimension of the rgSCHCmnEffTbl table refers to the CFI Index*/
2475    /*Initialize Efficency table for Tx Antenna Port Index 0 */
2476    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][0] = &rgSchCmnExtCfi1Eff[1];
2477    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][1] = &rgSchCmnExtCfi2Eff[1];
2478    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][2] = &rgSchCmnExtCfi3Eff[1];
2479    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][0][3] = &rgSchCmnExtCfi4Eff[1];
2480    /*Initialize Efficency table for Tx Antenna Port Index 1 */
2481    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][0] = &rgSchCmnExtCfi1Eff[1];
2482    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][1] = &rgSchCmnExtCfi2Eff[1];
2483    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][2] = &rgSchCmnExtCfi3Eff[1];
2484    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][1][3] = &rgSchCmnExtCfi4Eff[1];
2485    /*Initialize Efficency table for Tx Antenna Port Index 2 */
2486    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][0] = &rgSchCmnExtCfi1Eff[1];
2487    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][1] = &rgSchCmnExtCfi2Eff[1];
2488    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][2] = &rgSchCmnExtCfi3Eff[1];
2489    rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][2][3] = &rgSchCmnExtCfi4Eff[1];
2490
2491    /*Initialize CQI to TBS table for Layer Index 1 for Extended CP */
2492    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][0] = &rgSchCmnExtCfi1CqiToTbs[1];
2493    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][1] = &rgSchCmnExtCfi2CqiToTbs[1];
2494    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][2] = &rgSchCmnExtCfi3CqiToTbs[1];
2495    rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][3] = &rgSchCmnExtCfi4CqiToTbs[1];
2496    /* Activate this code when extended cp is supported */
2497    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2498    {
2499       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2500       {
2501          /* EfficiencyTbl calculation incase of 2 layers for extendedl CP  */
2502          rgSCHCmnCompEff( (U8)(i + 1 ), (U8)RG_SCH_CMN_EXT_CP, idx,\
2503                rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i]);
2504          rgSCHCmn2LyrCompEff((U8)(i + 1), (U8) RG_SCH_CMN_EXT_CP,idx, \
2505                rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i]);
2506       }
2507    }
2508
2509    for (idx = 0; idx < RG_SCH_CMN_MAX_ANT_CONF; idx++)
2510    {
2511       for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
2512       {
2513          effTbl = rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i];
2514          tbsTbl = rgSchCmnCqiToTbs[0][RG_SCH_CMN_EXT_CP][i];
2515          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2516                (j >= 0) && (k > 0); --j)
2517          {
2518             /* ADD CQI to MCS mapping correction
2519             * single dimensional array is replaced by 2 dimensions for different CFI*/
2520             if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
2521             {
2522                (*tbsTbl)[k--] = (U8)j;
2523             }
2524          }
2525          for (; k > 0; --k)
2526          {
2527             (*tbsTbl)[k] = 0;
2528          }
2529          /* effTbl,tbsTbl calculation incase of 2 layers for extended CP */
2530          effTbl = rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i];
2531          tbsTbl = rgSchCmnCqiToTbs[1][RG_SCH_CMN_EXT_CP][i];
2532          for (j = RG_SCH_CMN_NUM_TBS - 1, k = RG_SCH_CMN_MAX_CQI - 1;
2533                (j >= 0) && (k > 0); --j)
2534          {
2535            /* ADD CQI to MCS mapping correction
2536             * single dimensional array is replaced by 2 dimensions for different CFI*/
2537             if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
2538             {
2539                (*tbsTbl)[k--] = (U8)j;
2540             }
2541          }
2542          for (; k > 0; --k)
2543          {
2544             (*tbsTbl)[k] = 0;
2545          }
2546       }
2547    }
2548    RETVOID;
2549 }
2550 \f
2551 /**
2552  * @brief This function initializes all the data for the scheduler.
2553  *
2554  * @details
2555  *
2556  *     Function: rgSCHCmnUlInit
2557  *     Purpose:  This function initializes the following information:
2558  *               1. Efficiency table
2559  *               2. CQI to table index - It is one row for upto 3 RBs
2560  *                  and another row for greater than 3 RBs
2561  *                  currently extended prefix is compiled out.
2562  *     Invoked by: MAC intialization code..may be ActvInit
2563  *
2564  *  @return  Void
2565  *
2566  **/
2567 #ifdef ANSI
2568 PRIVATE Void rgSCHCmnUlInit
2569 (
2570 )
2571 #else
2572 PRIVATE Void rgSCHCmnUlInit()
2573 #endif
2574 {
2575    U8              *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
2576    RgSchCmnTbSzEff    *effTbl    = &rgSchCmnNorUlEff[0];
2577    CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
2578    S16              i;
2579    S16              j;
2580    TRC2(rgSCHCmnUlInit);
2581
2582    /* Initaializing new variable added for UL eff */
2583    rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
2584    /* Reason behind using 3 as the number of symbols to rule out for
2585     * efficiency table computation would be that we are using 2 symbols for
2586     * DMRS(1 in each slot) and 1 symbol for SRS*/
2587    rgSCHCmnCompUlEff(RGSCH_UL_SYM_DMRS_SRS,RG_SCH_CMN_NOR_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP]);
2588
2589    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2590          i >= 0 && j > 0; --i)
2591    {
2592       if ((*effTbl)[i] <= cqiTbl[j].eff)
2593       {
2594          mapTbl[j--] = (U8)i;
2595       }
2596    }
2597    for (; j > 0; --j)
2598    {
2599       mapTbl[j] = 0;
2600    }
2601    effTbl    = &rgSchCmnExtUlEff[0];
2602    mapTbl    = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_EXT_CP][0];
2603
2604    /* Initaializing new variable added for UL eff */
2605    rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP] = &rgSchCmnExtUlEff[0];
2606    /* Reason behind using 3 as the number of symbols to rule out for
2607     * efficiency table computation would be that we are using 2 symbols for
2608     * DMRS(1 in each slot) and 1 symbol for SRS*/
2609    rgSCHCmnCompUlEff(3,RG_SCH_CMN_EXT_CP,rgSchCmnUlEffTbl[RG_SCH_CMN_EXT_CP]);
2610
2611    for (i = RGSCH_NUM_ITBS - 1, j = RG_SCH_CMN_UL_NUM_CQI - 1;
2612          i >= 0 && j > 0; --i)
2613    {
2614       if ((*effTbl)[i] <= cqiTbl[j].eff)
2615       {
2616          mapTbl[j--] = (U8)i;
2617       }
2618    }
2619    for (; j > 0; --j)
2620    {
2621       mapTbl[j] = 0;
2622    }
2623    rgSCHPwrInit();
2624    RETVOID;
2625 }
2626
2627 /**
2628  * @brief This function initializes all the data for the scheduler.
2629  *
2630  * @details
2631  *
2632  *     Function: rgSCHCmnInit
2633  *     Purpose:  This function initializes the following information:
2634  *               1. Efficiency table
2635  *               2. CQI to table index - It is one row for upto 3 RBs
2636  *                  and another row for greater than 3 RBs
2637  *                  currently extended prefix is compiled out.
2638  *     Invoked by: MAC intialization code..may be ActvInit
2639  *
2640  *  @return  Void
2641  *
2642  **/
2643 #ifdef ANSI
2644 PUBLIC Void rgSCHCmnInit
2645 (
2646 )
2647 #else
2648 PUBLIC Void rgSCHCmnInit()
2649 #endif
2650 {
2651    U8   idx;
2652    TRC2(rgSCHCmnInit);
2653
2654    rgSCHCmnDlInit();
2655    rgSCHCmnUlInit();
2656 #ifdef EMTC_ENABLE
2657    rgSCHEmtcCmnDlInit();
2658    rgSCHEmtcCmnUlInit();
2659 #endif      
2660 #ifdef LTEMAC_SPS
2661    rgSCHCmnSpsInit();
2662 #endif
2663
2664    /* Init the function pointers */
2665    rgSchCmnApis.rgSCHRgrUeCfg         = rgSCHCmnRgrUeCfg;
2666    rgSchCmnApis.rgSCHRgrUeRecfg       = rgSCHCmnRgrUeRecfg;
2667    rgSchCmnApis.rgSCHFreeUe           = rgSCHCmnUeDel;
2668    rgSchCmnApis.rgSCHRgrCellCfg       = rgSCHCmnRgrCellCfg;
2669    rgSchCmnApis.rgSCHRgrCellRecfg     = rgSCHCmnRgrCellRecfg;
2670    rgSchCmnApis.rgSCHFreeCell         = rgSCHCmnCellDel;
2671    rgSchCmnApis.rgSCHRgrLchCfg        = rgSCHCmnRgrLchCfg;
2672    rgSchCmnApis.rgSCHRgrLcgCfg        = rgSCHCmnRgrLcgCfg;
2673    rgSchCmnApis.rgSCHRgrLchRecfg      = rgSCHCmnRgrLchRecfg;
2674    rgSchCmnApis.rgSCHRgrLcgRecfg      = rgSCHCmnRgrLcgRecfg;
2675    rgSchCmnApis.rgSCHFreeDlLc         = rgSCHCmnFreeDlLc;
2676    rgSchCmnApis.rgSCHFreeLcg          = rgSCHCmnLcgDel;
2677    rgSchCmnApis.rgSCHRgrLchDel        = rgSCHCmnRgrLchDel;
2678    rgSchCmnApis.rgSCHActvtUlUe        = rgSCHCmnActvtUlUe;
2679    rgSchCmnApis.rgSCHActvtDlUe        = rgSCHCmnActvtDlUe;
2680    rgSchCmnApis.rgSCHHdlUlTransInd    = rgSCHCmnHdlUlTransInd;
2681    rgSchCmnApis.rgSCHDlDedBoUpd       = rgSCHCmnDlDedBoUpd;
2682    rgSchCmnApis.rgSCHUlRecMsg3Alloc   = rgSCHCmnUlRecMsg3Alloc;
2683    rgSchCmnApis.rgSCHUlCqiInd         = rgSCHCmnUlCqiInd;
2684    rgSchCmnApis.rgSCHPucchDeltaPwrInd = rgSCHPwrPucchDeltaInd;
2685    rgSchCmnApis.rgSCHUlHqProcForUe    = rgSCHCmnUlHqProcForUe;
2686 #ifdef RG_UNUSED
2687    rgSchCmnApis.rgSCHUpdUlHqProc      = rgSCHCmnUpdUlHqProc;
2688 #endif
2689    rgSchCmnApis.rgSCHUpdBsrShort      = rgSCHCmnUpdBsrShort;
2690    rgSchCmnApis.rgSCHUpdBsrTrunc      = rgSCHCmnUpdBsrTrunc;
2691    rgSchCmnApis.rgSCHUpdBsrLong       = rgSCHCmnUpdBsrLong;
2692    rgSchCmnApis.rgSCHUpdPhr           = rgSCHCmnUpdPhr;
2693    rgSchCmnApis.rgSCHUpdExtPhr        = rgSCHCmnUpdExtPhr;
2694    rgSchCmnApis.rgSCHContResUlGrant   = rgSCHCmnContResUlGrant;
2695    rgSchCmnApis.rgSCHSrRcvd           = rgSCHCmnSrRcvd;
2696    rgSchCmnApis.rgSCHFirstRcptnReq    = rgSCHCmnFirstRcptnReq;
2697    rgSchCmnApis.rgSCHNextRcptnReq     = rgSCHCmnNextRcptnReq;
2698    rgSchCmnApis.rgSCHFirstHqFdbkAlloc = rgSCHCmnFirstHqFdbkAlloc;
2699    rgSchCmnApis.rgSCHNextHqFdbkAlloc  = rgSCHCmnNextHqFdbkAlloc;
2700    rgSchCmnApis.rgSCHDlProcAddToRetx  = rgSCHCmnDlProcAddToRetx;
2701    rgSchCmnApis.rgSCHDlCqiInd         = rgSCHCmnDlCqiInd;
2702 #ifdef EMTC_ENABLE
2703    rgSchCmnApis.rgSCHUlProcAddToRetx  = rgSCHCmnEmtcUlProcAddToRetx;
2704 #endif
2705 #ifdef TFU_UPGRADE
2706    rgSchCmnApis.rgSCHSrsInd           = rgSCHCmnSrsInd;
2707 #endif
2708    rgSchCmnApis.rgSCHDlTARpt          = rgSCHCmnDlTARpt;
2709    rgSchCmnApis.rgSCHDlRlsSubFrm      = rgSCHCmnDlRlsSubFrm;
2710    rgSchCmnApis.rgSCHUeReset          = rgSCHCmnUeReset;
2711 #ifdef LTEMAC_SPS
2712    rgSchCmnApis.rgSCHHdlCrntiCE         = rgSCHCmnHdlCrntiCE;
2713    rgSchCmnApis.rgSCHDlProcAck        = rgSCHCmnDlProcAck;
2714    rgSchCmnApis.rgSCHDlRelPdcchFbk    = rgSCHCmnDlRelPdcchFbk;
2715    rgSchCmnApis.rgSCHUlSpsRelInd      = rgSCHCmnUlSpsRelInd;
2716    rgSchCmnApis.rgSCHUlSpsActInd      = rgSCHCmnUlSpsActInd;
2717    rgSchCmnApis.rgSCHUlCrcFailInd     = rgSCHCmnUlCrcFailInd;
2718    rgSchCmnApis.rgSCHUlCrcInd     = rgSCHCmnUlCrcInd;
2719 #endif
2720    rgSchCmnApis.rgSCHDrxStrtInActvTmrInUl = rgSCHCmnDrxStrtInActvTmrInUl;
2721    rgSchCmnApis.rgSCHUpdUeDataIndLcg      = rgSCHCmnUpdUeDataIndLcg;
2722
2723    for (idx = 0; idx < RGSCH_NUM_SCHEDULERS; ++idx)
2724    {
2725       rgSchUlSchdInits[idx](&rgSchUlSchdTbl[idx]);
2726       rgSchDlSchdInits[idx](&rgSchDlSchdTbl[idx]);
2727    }
2728 #ifdef EMTC_ENABLE 
2729    for (idx = 0; idx < RGSCH_NUM_EMTC_SCHEDULERS; ++idx)
2730    {
2731       rgSchEmtcUlSchdInits[idx](&rgSchEmtcUlSchdTbl[idx]);
2732       rgSchEmtcDlSchdInits[idx](&rgSchEmtcDlSchdTbl[idx]);
2733    }
2734 #endif
2735 #if (defined (RG_PHASE2_SCHED) && defined(TFU_UPGRADE))
2736    for (idx = 0; idx < RGSCH_NUM_DLFS_SCHEDULERS; ++idx)
2737    {
2738       rgSchDlfsSchdInits[idx](&rgSchDlfsSchdTbl[idx]);
2739    }
2740 #endif
2741 #ifdef LTE_ADV
2742    rgSchCmnApis.rgSCHRgrSCellUeCfg         = rgSCHCmnRgrSCellUeCfg;
2743    rgSchCmnApis.rgSCHRgrSCellUeDel         = rgSCHCmnRgrSCellUeDel;
2744 #endif
2745    RETVOID;
2746 }
2747
2748 \f
2749 /**
2750  * @brief This function is a wrapper to call scheduler specific API.
2751  *
2752  * @details
2753  *
2754  *     Function: rgSCHCmnDlRlsSubFrm
2755  *     Purpose:  Releases scheduler Information from DL SubFrm.
2756  *
2757  *     Invoked by: DHM
2758  *
2759  *  @param[in]   RgSchCellCb     *cell
2760  *  @param[out]  CmLteTimingInfo frm
2761  *  @return  Void
2762  *
2763  **/
2764 #ifdef ANSI
2765 PUBLIC Void rgSCHCmnDlRlsSubFrm
2766 (
2767 RgSchCellCb        *cell,
2768 CmLteTimingInfo   frm
2769 )
2770 #else
2771 PUBLIC Void rgSCHCmnDlRlsSubFrm(cell, frm)
2772 RgSchCellCb        *cell;
2773 CmLteTimingInfo    frm;
2774 #endif
2775 {
2776    RgSchCmnCell        *cellSch = RG_SCH_CMN_GET_CELL(cell);
2777    RgSchDlSf           *sf;
2778
2779    TRC2(rgSCHCmnDlRlsSubFrm);
2780
2781    /* Get the pointer to the subframe */
2782    sf = rgSCHUtlSubFrmGet(cell, frm);
2783
2784    rgSCHUtlSubFrmPut(cell, sf);
2785    if (sf->dlfsSf)
2786    {
2787       /* Re-initialize DLFS specific information for the sub-frame */
2788       cellSch->apisDlfs->rgSCHDlfsReinitSf(cell, sf);
2789    }
2790    RETVOID;
2791 }
2792
2793
2794 \f
2795 /**
2796  * @brief This function is the starting function for DL allocation.
2797  *
2798  * @details
2799  *
2800  *     Function: rgSCHCmnDlCmnChAlloc
2801  *     Purpose:  Scheduling for downlink. It performs allocation in the order
2802  *               of priority wich BCCH/PCH first, CCCH, Random Access and TA.
2803  *
2804  *     Invoked by: Scheduler
2805  *
2806  *  @param[in]  RgSchCellCb*           cell
2807  *  @param[out] RgSchCmnDlRbAllocInfo* allocInfo
2808  *  @return  Void
2809  *
2810  **/
2811 #ifdef ANSI
2812 PRIVATE Void rgSCHCmnDlCcchRarAlloc
2813 (
2814 RgSchCellCb             *cell
2815 )
2816 #else
2817 PRIVATE Void rgSCHCmnDlCcchRarAlloc(cell)
2818 RgSchCellCb             *cell;
2819 #endif
2820 {
2821    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
2822
2823    TRC2(rgSCHCmnDlCcchRarAlloc);
2824
2825    rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
2826    /* LTE_ADV_FLAG_REMOVED_START */
2827    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2828    {
2829       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2830       {
2831          /*eNodeB need to blank the subframe */
2832       }
2833       else
2834       {
2835          rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2836       }
2837    }
2838    else
2839    {
2840       rgSCHCmnDlCcchTx(cell, &cellSch->allocInfo);
2841    }
2842    /* LTE_ADV_FLAG_REMOVED_END */
2843
2844 #ifdef RGR_V1
2845
2846    /*Added these function calls for processing CCCH SDU arriving
2847     * after guard timer expiry.Functions differ from above two functions
2848     * in using ueCb instead of raCb.*/
2849    rgSCHCmnDlCcchSduRetx(cell, &cellSch->allocInfo);
2850    /* LTE_ADV_FLAG_REMOVED_START */
2851    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2852    {
2853       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2854       {
2855          /*eNodeB need to blank the subframe */
2856       }
2857       else
2858       {
2859          rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2860       }
2861    }
2862    else
2863    {
2864       rgSCHCmnDlCcchSduTx(cell, &cellSch->allocInfo);
2865    }
2866    /* LTE_ADV_FLAG_REMOVED_END */
2867 #endif
2868
2869 #ifdef LTE_TDD
2870    if(cellSch->ul.msg3SchdIdx != RGSCH_INVALID_INFO)
2871    {
2872       /* Do not schedule msg3 if there is a CFI change ongoing */
2873       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2874       {
2875          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2876       }
2877    }
2878 #else
2879    /* LTE_ADV_FLAG_REMOVED_START */
2880    if(RG_SCH_ABS_ENABLED_ABS_SF == cell->lteAdvCb.absDlSfInfo)
2881    {
2882       if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
2883       {
2884          /*eNodeB need to blank the subframe */
2885       }
2886       else
2887       {
2888          /* Do not schedule msg3 if there is a CFI change ongoing */
2889          if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2890          {
2891             rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2892          }
2893       }
2894    }
2895    else
2896    {
2897       /* Do not schedule msg3 if there is a CFI change ongoing */
2898       if (cellSch->dl.currCfi == cellSch->dl.newCfi)
2899       {
2900          rgSCHCmnDlRaRsp(cell, &cellSch->allocInfo);
2901       }
2902    }
2903    /* LTE_ADV_FLAG_REMOVED_END */
2904 #endif
2905
2906    RETVOID;
2907 }
2908
2909 #ifdef RGR_V1
2910 /**
2911  * @brief Scheduling for CCCH SDU.
2912  *
2913  * @details
2914  *
2915  *     Function: rgSCHCmnCcchSduAlloc
2916  *     Purpose:  Scheduling for CCCH SDU
2917  *
2918  *     Invoked by: Scheduler
2919  *
2920  *  @param[in]  RgSchCellCb*          cell
2921  *  @param[in]  RgSchUeCb*            ueCb
2922  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
2923  *  @return  S16
2924  *
2925  **/
2926 #ifdef ANSI
2927 PRIVATE S16 rgSCHCmnCcchSduAlloc
2928 (
2929 RgSchCellCb                *cell,
2930 RgSchUeCb                  *ueCb,
2931 RgSchCmnDlRbAllocInfo      *allocInfo
2932 )
2933 #else
2934 PRIVATE S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
2935 RgSchCellCb                *cell;
2936 RgSchUeCb                  *ueCb;
2937 RgSchCmnDlRbAllocInfo      *allocInfo;
2938 #endif
2939 {
2940    RgSchDlRbAlloc  *rbAllocInfo;
2941    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
2942    RgSchCmnDlUe       *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
2943
2944    TRC2(rgSCHCmnCcchSduAlloc);
2945
2946    /* Return if subframe BW exhausted */
2947    if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
2948        allocInfo->ccchSduAlloc.ccchSduDlSf->bwAssigned)
2949    {
2950       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2951          "bw<=bwAssigned for UEID:%d",ueCb->ueId);
2952       RETVALUE(RFAILED);
2953    }
2954
2955    if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
2956    {
2957       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2958          "rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
2959       RETVALUE(RFAILED);
2960    }
2961
2962    rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
2963    rbAllocInfo->dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
2964
2965    if (rgSCHCmnCcchSduDedAlloc(cell, ueCb) != ROK)
2966    {
2967       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
2968       rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
2969       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
2970          "rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
2971       RETVALUE(RFAILED);
2972    }
2973    cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
2974    ueDl->proc->reqLnk.node = (PTR)ueDl->proc;
2975    allocInfo->ccchSduAlloc.ccchSduDlSf->schdCcchUe++;
2976
2977    RETVALUE(ROK);
2978 }
2979 /**
2980  * @brief This function scheduler for downlink CCCH messages.
2981  *
2982  * @details
2983  *
2984  *     Function: rgSCHCmnDlCcchSduTx
2985  *     Purpose:  Scheduling for downlink CCCH
2986  *
2987  *     Invoked by: Scheduler
2988  *
2989  *  @param[in]  RgSchCellCb           *cell
2990  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
2991  *  @return  Void
2992  *
2993  **/
2994 #ifdef ANSI
2995 PRIVATE Void rgSCHCmnDlCcchSduTx
2996 (
2997 RgSchCellCb             *cell,
2998 RgSchCmnDlRbAllocInfo   *allocInfo
2999 )
3000 #else
3001 PRIVATE Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
3002 RgSchCellCb             *cell;
3003 RgSchCmnDlRbAllocInfo   *allocInfo;
3004 #endif
3005 {
3006    CmLList           *node;
3007    RgSchUeCb         *ueCb;
3008    RgSchCmnDlUe      *ueCmnDl;
3009    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3010
3011    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3012    
3013    TRC2(rgSCHCmnDlCcchSduTx);
3014
3015    node = cell->ccchSduUeLst.first;
3016    while(node)
3017    {
3018       if(cellSch->dl.maxCcchPerDlSf &&
3019             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3020       {
3021          break;
3022       }
3023       else
3024       {
3025          ueCb = (RgSchUeCb *)(node->node);
3026          ueCmnDl  = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3027          node = node->next;
3028          /* Fix : syed postpone scheduling for this
3029           * until msg4 is done */
3030          /* Fix : syed RLC can erroneously send CCCH SDU BO 
3031           * twice. Hence an extra guard to avoid if already 
3032           * scheduled for RETX */
3033          if ((!(ueCb->dl.dlInactvMask & RG_HQENT_INACTIVE)) &&
3034                (!ueCmnDl->proc))
3035          {
3036             if ((rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)) != ROK)
3037             {
3038                break;
3039             }
3040          }
3041          else
3042          {
3043             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"ERROR!! THIS SHOULD "
3044                      "NEVER HAPPEN for UEID:%d", ueCb->ueId);
3045             continue;
3046          }
3047       }
3048    }
3049    RETVOID;
3050 }
3051 #endif
3052 \f
3053 /**
3054  * @brief This function scheduler for downlink CCCH messages.
3055  *
3056  * @details
3057  *
3058  *     Function: rgSCHCmnDlCcchTx
3059  *     Purpose:  Scheduling for downlink CCCH
3060  *
3061  *     Invoked by: Scheduler
3062  *
3063  *  @param[in]  RgSchCellCb           *cell
3064  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3065  *  @return  Void
3066  *
3067  **/
3068 #ifdef ANSI
3069 PRIVATE Void rgSCHCmnDlCcchTx
3070 (
3071 RgSchCellCb             *cell,
3072 RgSchCmnDlRbAllocInfo   *allocInfo
3073 )
3074 #else
3075 PRIVATE Void rgSCHCmnDlCcchTx(cell, allocInfo)
3076 RgSchCellCb             *cell;
3077 RgSchCmnDlRbAllocInfo   *allocInfo;
3078 #endif
3079 {
3080    CmLList           *node;
3081    RgSchRaCb         *raCb;
3082    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3083    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3084    
3085    TRC2(rgSCHCmnDlCcchTx);
3086
3087    node = cell->raInfo.toBeSchdLst.first;
3088    while(node)
3089    {
3090       if(cellSch->dl.maxCcchPerDlSf &&
3091             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3092       {
3093          break;
3094       }
3095       else
3096       {
3097
3098          raCb = (RgSchRaCb *)(node->node);
3099          node = node->next;
3100          /* Address allocation for this UE for MSG 4 */
3101          /* Allocation for Msg4 */
3102          if ((rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)) != ROK)
3103          {
3104             break;
3105          }
3106       }
3107    }
3108    RETVOID;
3109 }
3110
3111 #ifdef RGR_V1
3112 /**
3113  * @brief This function scheduler for downlink CCCH messages.
3114  *
3115  * @details
3116  *
3117  *     Function: rgSCHCmnDlCcchSduRetx
3118  *     Purpose:  Scheduling for downlink CCCH
3119  *
3120  *     Invoked by: Scheduler
3121  *
3122  *  @param[in]  RgSchCellCb           *cell
3123  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3124  *  @return  Void
3125  *
3126  **/
3127 #ifdef ANSI
3128 PRIVATE Void rgSCHCmnDlCcchSduRetx
3129 (
3130 RgSchCellCb             *cell,
3131 RgSchCmnDlRbAllocInfo   *allocInfo
3132 )
3133 #else
3134 PRIVATE Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
3135 RgSchCellCb             *cell;
3136 RgSchCmnDlRbAllocInfo   *allocInfo;
3137 #endif
3138 {
3139    RgSchDlRbAlloc  *rbAllocInfo;
3140    CmLList           *node;
3141    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3142    RgSchUeCb         *ueCb;
3143    RgSchDlHqProcCb   *hqP;
3144    U8                retxBw = 0;
3145    RgSchCmnDlUe      *ueDl;
3146    RgSchDlSf         *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
3147    
3148    TRC2(rgSCHCmnDlCcchSduRetx);
3149
3150    node = cellSch->dl.ccchSduRetxLst.first;
3151    while(node)
3152    {
3153       if(cellSch->dl.maxCcchPerDlSf &&
3154             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3155       {
3156          break;
3157       }
3158       else
3159       {
3160
3161          hqP = (RgSchDlHqProcCb *)(node->node);
3162          node = node->next;
3163
3164          /* DwPts Scheduling Changes Start */      
3165 #ifdef LTE_TDD
3166          if (rgSCHCmnRetxAvoidTdd(allocInfo->ccchSduAlloc.ccchSduDlSf, 
3167                   cell, hqP) == TRUE)
3168          {
3169             continue;  
3170          }
3171 #endif
3172          /* DwPts Scheduling Changes End */     
3173
3174          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3175          {
3176             break;
3177          }
3178          ueCb = (RgSchUeCb*)(hqP->hqE->ue);
3179          ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
3180
3181          rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
3182          /* Fill RB Alloc Info */
3183          rbAllocInfo->dlSf = dlSf;
3184          rbAllocInfo->tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3185          rbAllocInfo->rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3186          /* Fix : syed iMcs setting did not correspond to RETX */
3187          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3188                rbAllocInfo->tbInfo[0].imcs);
3189          rbAllocInfo->rnti = ueCb->ueId;
3190          rbAllocInfo->tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3191          /* Fix : syed Copying info in entirety without depending on stale TX information */
3192          rbAllocInfo->tbInfo[0].tbCb = &hqP->tbInfo[0];
3193          rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
3194          /* Fix : syed Assigning proc to scratchpad */ 
3195          ueDl->proc = hqP;
3196
3197          retxBw += rbAllocInfo->rbsReq;
3198
3199          cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduRetxLst, \
3200                &hqP->reqLnk);
3201          hqP->reqLnk.node = (PTR)hqP;
3202          dlSf->schdCcchUe++;
3203       }
3204    }
3205    dlSf->bwAssigned += retxBw;
3206    RETVOID;
3207 }
3208 #endif
3209 \f
3210 /**
3211  * @brief This function scheduler for downlink CCCH messages.
3212  *
3213  * @details
3214  *
3215  *     Function: rgSCHCmnDlCcchRetx
3216  *     Purpose:  Scheduling for downlink CCCH
3217  *
3218  *     Invoked by: Scheduler
3219  *
3220  *  @param[in]  RgSchCellCb           *cell
3221  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3222  *  @return  Void
3223  *
3224  **/
3225 #ifdef ANSI
3226 PRIVATE Void rgSCHCmnDlCcchRetx
3227 (
3228 RgSchCellCb             *cell,
3229 RgSchCmnDlRbAllocInfo   *allocInfo
3230 )
3231 #else
3232 PRIVATE Void rgSCHCmnDlCcchRetx(cell, allocInfo)
3233 RgSchCellCb             *cell;
3234 RgSchCmnDlRbAllocInfo   *allocInfo;
3235 #endif
3236 {
3237    CmLList           *node;
3238    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
3239    RgSchRaCb         *raCb;
3240    RgSchDlHqProcCb   *hqP;
3241    U8                retxBw = 0;
3242    RgSchDlSf         *dlSf = allocInfo->msg4Alloc.msg4DlSf;
3243         
3244    TRC2(rgSCHCmnDlCcchRetx);
3245
3246    node = cellSch->dl.msg4RetxLst.first;
3247    while(node)
3248    {
3249       if(cellSch->dl.maxCcchPerDlSf &&
3250             dlSf->schdCcchUe == cellSch->dl.maxCcchPerDlSf)
3251       {
3252          break;
3253       }
3254       else
3255       {
3256          hqP = (RgSchDlHqProcCb *)(node->node);
3257
3258          node = node->next;
3259
3260          /* DwPts Scheduling Changes Start */     
3261 #ifdef LTE_TDD      
3262          if (rgSCHCmnRetxAvoidTdd(allocInfo->msg4Alloc.msg4DlSf, 
3263                   cell, hqP) == TRUE)
3264          {
3265             continue;  
3266          }
3267 #endif      
3268          /* DwPts Scheduling Changes End */      
3269
3270          if (hqP->tbInfo[0].dlGrnt.numRb > (dlSf->bw - dlSf->bwAssigned))
3271          {
3272             break;
3273          }
3274          raCb = (RgSchRaCb*)(hqP->hqE->raCb);
3275          /* Fill RB Alloc Info */
3276          raCb->rbAllocInfo.dlSf = dlSf;
3277          raCb->rbAllocInfo.tbInfo[0].bytesReq =  hqP->tbInfo[0].ccchSchdInfo.totBytes;
3278          raCb->rbAllocInfo.rbsReq = hqP->tbInfo[0].dlGrnt.numRb;
3279          /* Fix : syed iMcs setting did not correspond to RETX */
3280          RG_SCH_CMN_GET_MCS_FOR_RETX((&hqP->tbInfo[0]), 
3281                raCb->rbAllocInfo.tbInfo[0].imcs);
3282          raCb->rbAllocInfo.rnti = raCb->tmpCrnti;
3283          raCb->rbAllocInfo.tbInfo[0].noLyr = hqP->tbInfo[0].numLyrs;
3284          /* Fix; syed Copying info in entirety without depending on stale TX information */
3285          raCb->rbAllocInfo.tbInfo[0].tbCb = &hqP->tbInfo[0];
3286          raCb->rbAllocInfo.tbInfo[0].schdlngForTb = TRUE;
3287
3288          retxBw += raCb->rbAllocInfo.rbsReq;
3289
3290          cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4RetxLst, \
3291                &hqP->reqLnk);
3292          hqP->reqLnk.node = (PTR)hqP;
3293          dlSf->schdCcchUe++;
3294       }
3295    }
3296    dlSf->bwAssigned += retxBw;
3297    RETVOID;
3298 }
3299
3300 \f
3301 /**
3302  * @brief This function implements scheduler DL allocation for
3303  *        for broadcast (on PDSCH) and paging.
3304  *
3305  * @details
3306  *
3307  *     Function: rgSCHCmnDlBcchPcch
3308  *     Purpose:  This function implements scheduler for DL allocation
3309  *               for broadcast (on PDSCH) and paging.
3310  *
3311  *     Invoked by: Scheduler
3312  *
3313  *  @param[in]  RgSchCellCb*     cell
3314  *  @return  S16
3315  *      -# ROK
3316  *      -# RFAILED
3317  **/
3318 #ifdef ANSI
3319 PRIVATE Void rgSCHCmnDlBcchPcch
3320 (
3321 RgSchCellCb             *cell,
3322 RgSchCmnDlRbAllocInfo   *allocInfo,
3323 RgInfSfAlloc            *subfrmAlloc
3324 )
3325 #else
3326 PRIVATE Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
3327 RgSchCellCb             *cell;
3328 RgSchCmnDlRbAllocInfo   *allocInfo;
3329 RgInfSfAlloc            *subfrmAlloc;
3330 #endif
3331 {
3332    CmLteTimingInfo   frm;
3333    RgSchDlSf         *sf;
3334    RgSchClcDlLcCb    *pcch;
3335    RgSchClcBoRpt     *bo;
3336 #ifndef RGR_SI_SCH
3337    Bool              valid;
3338    RgSchClcDlLcCb    *bcch, *bch;
3339 #endif/*RGR_SI_SCH*/
3340
3341
3342    TRC2(rgSCHCmnDlBcchPcch);
3343
3344    frm   = cell->crntTime;
3345 #ifdef LTEMAC_HDFDD
3346    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
3347       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
3348    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
3349 #else
3350   // RGSCH_SUBFRAME_INDEX(frm);
3351    //RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
3352 #endif
3353
3354    /* Compute the subframe for which allocation is being made        */
3355    /* essentially, we need pointer to the dl frame for this subframe */
3356    sf = rgSCHUtlSubFrmGet(cell, frm);
3357
3358
3359 #ifndef RGR_SI_SCH
3360    bch = rgSCHDbmGetBcchOnBch(cell);
3361 #if (ERRCLASS & ERRCLS_DEBUG)
3362    if (bch == NULLP)
3363    {
3364       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
3365       RETVOID;
3366    }
3367 #endif
3368    if (bch->boLst.first != NULLP)
3369    {
3370       bo = (RgSchClcBoRpt *)(bch->boLst.first->node);
3371       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3372       {
3373          sf->bch.tbSize = bo->bo;
3374          cmLListDelFrm(&bch->boLst, bch->boLst.first);
3375          /* ccpu00117052 - MOD - Passing double pointer
3376             for proper NULLP assignment*/
3377          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(*bo));
3378          rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, bch->lcId,TRUE);
3379       }
3380    }
3381    else
3382    {
3383       if ((frm.sfn % 4 == 0) && (frm.subframe == 0))
3384       {
3385       }
3386    }
3387
3388    allocInfo->bcchAlloc.schdFirst = FALSE;
3389    bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
3390 #if (ERRCLASS & ERRCLS_DEBUG)
3391    if (bcch == NULLP)
3392    {
3393       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3394       RETVOID;
3395    }
3396 #endif
3397    if (bcch->boLst.first != NULLP)
3398    {
3399       bo = (RgSchClcBoRpt *)(bcch->boLst.first->node);
3400
3401       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3402       {
3403          allocInfo->bcchAlloc.schdFirst = TRUE;
3404          /* Time to perform allocation for this BCCH transmission */
3405          rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3406       }
3407    }
3408
3409    if(!allocInfo->bcchAlloc.schdFirst)
3410    {
3411       CmLList   *lnk;
3412       bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
3413 #if (ERRCLASS & ERRCLS_DEBUG)
3414       if (bcch == NULLP)
3415       {
3416          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
3417          RETVOID;
3418       }
3419 #endif
3420       lnk = bcch->boLst.first;
3421       while (lnk != NULLP)
3422       {
3423          bo = (RgSchClcBoRpt *)(lnk->node);
3424          lnk = lnk->next;
3425          valid = rgSCHCmnChkInWin(frm, bo->timeToTx, bo->maxTimeToTx);
3426
3427          if(valid)
3428          {
3429             bo->i = RGSCH_CALC_SF_DIFF(frm, bo->timeToTx);
3430             /* Time to perform allocation for this BCCH transmission */
3431             rgSCHCmnClcAlloc(cell, sf, bcch, RGSCH_SI_RNTI, allocInfo);
3432             break;
3433          }
3434          else
3435          {
3436             valid = rgSCHCmnChkPastWin(frm, bo->maxTimeToTx);
3437             if(valid)
3438             {
3439                cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
3440                /* ccpu00117052 - MOD - Passing double pointer
3441                   for proper NULLP assignment*/
3442                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo,
3443                      sizeof(RgSchClcBoRpt));
3444             }
3445          }
3446       }
3447    }
3448 #else
3449    rgSCHDlSiSched(cell, allocInfo, subfrmAlloc);
3450 #endif/*RGR_SI_SCH*/
3451
3452    pcch = rgSCHDbmGetPcch(cell);
3453 #ifdef ERRCLS_KW
3454    if (pcch == NULLP)
3455    {
3456       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
3457       RETVOID;
3458    }
3459 #endif
3460    if (pcch->boLst.first != NULLP)
3461    {
3462       bo = (RgSchClcBoRpt *)(pcch->boLst.first->node);
3463
3464       if (RGSCH_TIMEINFO_SAME(frm, bo->timeToTx))
3465       {
3466          /* Time to perform allocation for this PCCH transmission */
3467          rgSCHCmnClcAlloc(cell, sf, pcch, RGSCH_P_RNTI, allocInfo);
3468       }
3469    }
3470    RETVOID;
3471 }
3472
3473 /*
3474 *
3475 *       Fun:   rgSCHCmnChkInWin
3476 *
3477 *       Desc:  This function checks if frm occurs in window
3478 *
3479 *       Ret:   TRUE      - if in window
3480 *              FALSE     - otherwise
3481 *
3482 *       Notes: None
3483 *
3484 *       File:  rg_sch_cmn.c
3485 *
3486 */
3487 #ifdef ANSI
3488 PUBLIC Bool rgSCHCmnChkInWin
3489 (
3490 CmLteTimingInfo   frm,
3491 CmLteTimingInfo   start,
3492 CmLteTimingInfo   end
3493 )
3494 #else
3495 PUBLIC Bool rgSCHCmnChkInWin(frm, start, end)
3496 CmLteTimingInfo   frm;
3497 CmLteTimingInfo   start;
3498 CmLteTimingInfo   end;
3499 #endif
3500 {
3501    Bool    inWin = FALSE;
3502
3503    TRC2(rgSCHCmnChkInWin);
3504
3505    if (end.sfn > start.sfn)
3506    {
3507       if (frm.sfn > start.sfn
3508             || (frm.sfn == start.sfn && frm.slot >= start.slot))
3509       {
3510          if (frm.sfn < end.sfn
3511 #ifdef EMTC_ENABLE
3512                || (frm.sfn == end.sfn && frm.slot <= end.slot))
3513 #else
3514                || (frm.sfn == end.sfn && frm.slot <= start.slot))
3515 #endif
3516          {
3517             inWin = TRUE;
3518          }
3519       }
3520    }
3521    /* Testing for wrap around, sfn wraparound check should be enough */
3522    else if (end.sfn < start.sfn)
3523    {
3524       if (frm.sfn > start.sfn
3525             || (frm.sfn == start.sfn && frm.slot >= start.slot))
3526       {
3527          inWin = TRUE;
3528       }
3529       else
3530       {
3531          if (frm.sfn < end.sfn
3532                || (frm.sfn == end.sfn && frm.slot <= end.slot))
3533          {
3534             inWin = TRUE;
3535          }
3536       }
3537    }
3538    else  /* start.sfn == end.sfn */
3539    {
3540       if (frm.sfn == start.sfn
3541             && (frm.slot >= start.slot
3542                && frm.slot <= end.slot))
3543       {
3544          inWin = TRUE;
3545       }
3546    }
3547
3548    RETVALUE(inWin);
3549 } /* end of rgSCHCmnChkInWin*/
3550
3551 /*
3552 *
3553 *       Fun:   rgSCHCmnChkPastWin
3554 *
3555 *       Desc:  This function checks if frm has gone past window edge
3556 *
3557 *       Ret:   TRUE      - if past window edge
3558 *              FALSE     - otherwise
3559 *
3560 *       Notes: None
3561 *
3562 *       File:  rg_sch_cmn.c
3563 *
3564 */
3565 #ifdef ANSI
3566 PUBLIC Bool rgSCHCmnChkPastWin
3567 (
3568 CmLteTimingInfo   frm,
3569 CmLteTimingInfo   end
3570 )
3571 #else
3572 PUBLIC Bool rgSCHCmnChkPastWin(frm, end)
3573 CmLteTimingInfo   frm;
3574 CmLteTimingInfo   end;
3575 #endif
3576 {
3577    CmLteTimingInfo  refFrm = end;
3578    Bool             pastWin;
3579
3580    TRC2(rgSCHCmnChkPastWin);
3581
3582    RGSCH_INCR_FRAME(refFrm.sfn);
3583    RGSCH_INCR_SUB_FRAME(end, 1);
3584    pastWin = rgSCHCmnChkInWin(frm, end, refFrm);
3585
3586    RETVALUE(pastWin);
3587 } /* end of rgSCHCmnChkPastWin*/
3588 \f
3589 /**
3590  * @brief This function implements allocation of the resources for common
3591  * channels BCCH, PCCH.
3592  *
3593  * @details
3594  *
3595  *     Function: rgSCHCmnClcAlloc
3596  *     Purpose:  This function implements selection of number of RBs based
3597  *               the allowed grant for the service. It is also responsible
3598  *               for selection of MCS for the transmission.
3599  *
3600  *     Invoked by: Scheduler
3601  *
3602  *  @param[in]  RgSchCellCb                *cell,
3603  *  @param[in]  RgSchDlSf                  *sf,
3604  *  @param[in]  RgSchClcDlLcCb             *lch,
3605  *  @param[in]  U16                        rnti,
3606  *  @param[out] RgSchCmnDlRbAllocInfo      *allocInfo
3607  *  @return     Void
3608  *
3609  **/
3610 #ifdef ANSI
3611 PRIVATE Void rgSCHCmnClcAlloc
3612 (
3613 RgSchCellCb             *cell,
3614 RgSchDlSf               *sf,
3615 RgSchClcDlLcCb          *lch,
3616 U16                     rnti,
3617 RgSchCmnDlRbAllocInfo   *allocInfo
3618 )
3619 #else
3620 PRIVATE Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
3621 RgSchCellCb             *cell;
3622 RgSchDlSf               *sf;
3623 RgSchClcDlLcCb          *lch;
3624 U16                     rnti;
3625 RgSchCmnDlRbAllocInfo   *allocInfo;
3626 #endif
3627 {
3628    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
3629    RgSchClcBoRpt        *bo;
3630    U32                  rb=0;
3631    U8                   mcs;
3632    U32                  tbs;
3633 #ifdef LTE_TDD   
3634    U8                   lostRe;
3635    U8                   cfi = cellDl->currCfi;  
3636 #endif
3637
3638    TRC2(rgSCHCmnClcAlloc);
3639
3640    bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
3641
3642    mcs = bo->mcs;
3643    tbs = bo->bo;
3644    /* rgSCHCmnClcRbAllocForFxdTb(cell, bo->bo, cellDl->ccchCqi, &rb);*/
3645    if(cellDl->bitsPerRb==0)
3646    {
3647       while ((rgTbSzTbl[0][0][rb]) < (tbs*8))
3648       {
3649          rb++;
3650       }
3651       rb = rb+1;
3652    }
3653    else
3654    {
3655       rb = RGSCH_CEIL((tbs*8), cellDl->bitsPerRb);
3656    }
3657    /* DwPTS Scheduling Changes Start */   
3658 #ifdef LTE_TDD
3659    if(sf->sfType == RG_SCH_SPL_SF_DATA) 
3660    {
3661       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
3662
3663       /* Calculate the less RE's because of DwPTS */
3664       lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
3665
3666       /* Increase number of RBs in Spl SF to compensate for lost REs */
3667       rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
3668    }
3669 #endif
3670    /* DwPTS Scheduling Changes End */   
3671    /*ccpu00115595- end*/
3672    /* additional check to see if required RBs
3673     * exceeds the available */
3674    if (rb > sf->bw - sf->bwAssigned)
3675    {
3676       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
3677                 "failed for CRNTI:%d",rnti);
3678       RETVOID;
3679    }
3680
3681    /* Update the subframe Allocated BW field */
3682    sf->bwAssigned = sf->bwAssigned + rb;
3683    /* Fill in the BCCH/PCCH transmission info to the RBAllocInfo struct */
3684    if (rnti == RGSCH_SI_RNTI)
3685    {
3686       allocInfo->bcchAlloc.rnti = rnti;
3687       allocInfo->bcchAlloc.dlSf = sf;
3688       allocInfo->bcchAlloc.tbInfo[0].bytesReq = tbs;
3689       allocInfo->bcchAlloc.rbsReq = rb;
3690       allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
3691       allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
3692       /* Nprb indication at PHY for common Ch */
3693       allocInfo->bcchAlloc.nPrb = bo->nPrb;
3694    }
3695    else
3696    {
3697       allocInfo->pcchAlloc.rnti = rnti;
3698       allocInfo->pcchAlloc.dlSf = sf;
3699       allocInfo->pcchAlloc.tbInfo[0].bytesReq = tbs;
3700       allocInfo->pcchAlloc.rbsReq = rb;
3701       allocInfo->pcchAlloc.tbInfo[0].imcs = mcs;
3702       allocInfo->pcchAlloc.tbInfo[0].noLyr = 1;
3703       allocInfo->pcchAlloc.nPrb = bo->nPrb;
3704    }
3705    RETVOID;
3706 }
3707
3708 \f
3709 /**
3710  * @brief This function implements PDCCH allocation for common channels.
3711  *
3712  * @details
3713  *
3714  *     Function: rgSCHCmnCmnPdcchAlloc
3715  *     Purpose:  This function implements allocation of PDCCH for a UE.
3716  *               1. This uses index 0 of PDCCH table for efficiency.
3717  *               2. Uses he candidate PDCCH count for the aggr level.
3718  *               3. Look for availability for each candidate and choose
3719  *                  the first one available.
3720  *
3721  *     Invoked by: Scheduler
3722  *
3723  *  @param[in]  RgSchCellCb           *cell
3724  *  @param[in]  RgSchDlSf             *sf
3725  *  @return     RgSchPdcch *
3726  *               -# NULLP when unsuccessful
3727  *
3728  **/
3729 #ifdef ANSI
3730 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc
3731 (
3732 RgSchCellCb                *cell,
3733 RgSchDlSf                  *subFrm
3734 )
3735 #else
3736 PUBLIC RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
3737 RgSchCellCb                *cell;
3738 RgSchDlSf                  *subFrm;
3739 #endif
3740 {
3741    CmLteAggrLvl         aggrLvl;
3742    RgSchPdcchInfo       *pdcchInfo;
3743    RgSchPdcch           *pdcch;
3744    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3745    U8                   numCce;  /*store num CCEs based on 
3746                                   aggregation level */
3747    TRC2(rgSCHCmnCmnPdcchAlloc);
3748
3749    aggrLvl   = cellSch->dl.cmnChAggrLvl;
3750
3751    pdcchInfo = &(subFrm->pdcchInfo);
3752
3753     /* Updating the no. of nCce in pdcchInfo, in case if CFI
3754     * was changed  */
3755 #ifdef LTE_TDD
3756    if(subFrm->nCce != pdcchInfo->nCce)
3757    {   
3758       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
3759    }
3760 #else   
3761    if(cell->nCce != pdcchInfo->nCce)
3762    {
3763       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
3764    }
3765 #endif  
3766
3767    switch (aggrLvl)
3768    {
3769       case CM_LTE_AGGR_LVL4:
3770         numCce = 4;
3771         break;
3772       case CM_LTE_AGGR_LVL8:
3773         numCce = 8;
3774         break;
3775                 case CM_LTE_AGGR_LVL16:
3776         numCce = 16;
3777         break;
3778       default:
3779         RETVALUE(NULLP);
3780    }
3781
3782    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
3783    {
3784 #ifdef LTEMAC_SPS
3785       pdcch->isSpsRnti = FALSE;
3786 #endif
3787       /* Increment the CCE used counter in the current subframe */
3788       subFrm->cceCnt += numCce;
3789       pdcch->pdcchSearchSpace = RG_SCH_CMN_SEARCH_SPACE;
3790
3791       RETVALUE(pdcch);
3792    }
3793
3794    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
3795    subFrm->isCceFailure = TRUE;
3796
3797    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
3798             "PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u", 
3799             aggrLvl);
3800    RETVALUE(NULLP);
3801 }
3802
3803 \f
3804 /**
3805  * @brief This function implements bandwidth allocation for common channels.
3806  *
3807  * @details
3808  *
3809  *     Function: rgSCHCmnClcRbAlloc
3810  *     Purpose:  This function implements bandwith allocation logic
3811  *               for common control channels.
3812  *
3813  *     Invoked by: Scheduler
3814  *
3815  *  @param[in]  RgSchCellCb*  cell
3816  *  @param[in]  U32           bo
3817  *  @param[in]  U8            cqi
3818  *  @param[in]  U8            *rb
3819  *  @param[in]  U32           *tbs
3820  *  @param[in]  U8            *mcs
3821  *  @param[in]  RgSchDlSf     *sf
3822  *  @return  Void
3823  *
3824  **/
3825 #ifdef LTEMAC_SPS
3826 #ifdef ANSI
3827 PUBLIC Void rgSCHCmnClcRbAlloc
3828 (
3829 RgSchCellCb             *cell,
3830 U32                     bo,
3831 U8                      cqi,
3832 U8                      *rb,
3833 U32                     *tbs,
3834 U8                      *mcs,
3835 U8                      *iTbs,
3836 Bool                    isSpsBo,
3837 RgSchDlSf               *sf 
3838 )
3839 #else
3840 PUBLIC Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
3841 RgSchCellCb             *cell;
3842 U32                     bo;
3843 U8                      cqi;
3844 U8                      *rb;
3845 U32                     *tbs;
3846 U8                      *mcs;
3847 U8                      *iTbs;
3848 Bool                    isSpsBo;
3849 RgSchDlSf               *sf; 
3850 #endif
3851 #else
3852 #ifdef ANSI
3853 PRIVATE Void rgSCHCmnClcRbAlloc
3854 (
3855 RgSchCellCb             *cell,
3856 U32                     bo,
3857 U8                      cqi,
3858 U8                      *rb,
3859 U32                     *tbs,
3860 U8                      *mcs,
3861 RgSchDlSf               *sf 
3862 )
3863 #else
3864 PRIVATE Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
3865 RgSchCellCb             *cell;
3866 U32                     bo;
3867 U8                      cqi;
3868 U8                      *rb;
3869 U32                     *tbs;
3870 U8                      *mcs;
3871 RgSchDlSf               *sf; 
3872 #endif
3873 #endif /* LTEMAC_SPS */
3874 {
3875    U8                   iTbsVal;
3876    RgSchCmnTbSzEff      *effTbl;
3877    U32                  eff;
3878    U32                  noRes;
3879    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
3880    U8                   cfi = cellSch->dl.currCfi;
3881    U32                  tmpRb=0;
3882    TRC2(rgSCHCmnClcRbAlloc);
3883
3884    /* first get the CQI to MCS table and determine the number of RBs */
3885    effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
3886    iTbsVal = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[cqi];
3887    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3888
3889    /* Efficiency is number of bits per 1024 REs */
3890    eff  = (*effTbl)[iTbsVal];
3891
3892    /* Get the number of REs needed for this bo  */
3893    noRes = ((bo * 8 * 1024) / eff );
3894
3895    /* Get the number of RBs needed for this transmission */
3896    /* Number of RBs = No of REs / No of REs per RB       */
3897    tmpRb = RGSCH_CEIL(noRes, cellSch->dl.noResPerRb[cfi]);
3898    /* KWORK_FIX: added check to see if rb has crossed maxRb*/
3899    RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3900    if (tmpRb > cellSch->dl.maxDlBwPerUe)
3901    {
3902       tmpRb = cellSch->dl.maxDlBwPerUe;
3903    }
3904    while ((rgTbSzTbl[0][iTbsVal][tmpRb-1]/8) < bo && 
3905            (tmpRb < cellSch->dl.maxDlBwPerUe))
3906    {
3907       tmpRb++;
3908       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
3909    }
3910    *tbs =  rgTbSzTbl[0][iTbsVal][tmpRb-1]/8;
3911    *rb = (U8)tmpRb;
3912    RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
3913
3914    RETVOID;
3915 }
3916
3917 \f
3918
3919 /**
3920  * @brief Scheduling for MSG4.
3921  *
3922  * @details
3923  *
3924  *     Function: rgSCHCmnMsg4Alloc
3925  *     Purpose:  Scheduling for MSG4
3926  *
3927  *     Invoked by: Scheduler
3928  *
3929  *  @param[in]  RgSchCellCb*          cell
3930  *  @param[in]  RgSchRaCb*            raCb
3931  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
3932  *  @return  S16
3933  *
3934  **/
3935 #ifdef ANSI
3936 PRIVATE S16 rgSCHCmnMsg4Alloc
3937 (
3938 RgSchCellCb                *cell,
3939 RgSchRaCb                  *raCb,
3940 RgSchCmnDlRbAllocInfo      *allocInfo
3941 )
3942 #else
3943 PRIVATE S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
3944 RgSchCellCb                *cell;
3945 RgSchRaCb                  *raCb;
3946 RgSchCmnDlRbAllocInfo      *allocInfo;
3947 #endif
3948 {
3949    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
3950
3951    TRC2(rgSCHCmnMsg4Alloc);
3952
3953  /* SR_RACH_STATS : MSG4 TO BE TXED */
3954    rgNumMsg4ToBeTx++;
3955    /* Return if subframe BW exhausted */
3956    if (allocInfo->msg4Alloc.msg4DlSf->bw <=
3957        allocInfo->msg4Alloc.msg4DlSf->bwAssigned)
3958    {
3959       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
3960          "bw<=bwAssigned");
3961       RETVALUE(RFAILED);
3962    }
3963
3964    if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
3965    {
3966       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3967          "rgSCHDhmGetMsg4HqProc failed");
3968       RETVALUE(RFAILED);
3969    }
3970
3971    raCb->rbAllocInfo.dlSf = allocInfo->msg4Alloc.msg4DlSf;
3972
3973    if (rgSCHCmnMsg4DedAlloc(cell, raCb) != ROK)
3974    {
3975       /* Fix : syed Minor failure handling, release hqP if Unsuccessful */    
3976       rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
3977       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
3978          "rgSCHCmnMsg4DedAlloc failed.");
3979       RETVALUE(RFAILED);
3980    }
3981    cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
3982    raCb->dlHqE->msg4Proc->reqLnk.node = (PTR)raCb->dlHqE->msg4Proc;
3983    allocInfo->msg4Alloc.msg4DlSf->schdCcchUe++;
3984
3985    RETVALUE(ROK);
3986 }
3987
3988 \f
3989 /**
3990  * @brief This function implements PDCCH allocation for an UE.
3991  *
3992  * @details
3993  *
3994  *     Function: PdcchAlloc
3995  *     Purpose:  This function implements allocation of PDCCH for an UE.
3996  *               1. Get the aggregation level for the CQI of the UE.
3997  *               2. Get the candidate PDCCH count for the aggr level.
3998  *               3. Look for availability for each candidate and choose
3999  *                  the first one available.
4000  *
4001  *     Invoked by: Scheduler
4002  *
4003  *  @param[in]  cell
4004  *  @param[in]  subFrm
4005  *  @param[in]  cqi
4006  *  @param[in]  dciFrmt
4007  *  @return  RgSchPdcch *
4008  *         -# NULLP when unsuccessful
4009  *
4010  **/
4011 #ifdef ANSI
4012 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc
4013 (
4014 RgSchCellCb             *cell,
4015 RgSchUeCb               *ue,
4016 RgSchDlSf               *subFrm,
4017 U8                      cqi,
4018 TfuDciFormat            dciFrmt,
4019 Bool                    isDtx
4020 )
4021 #else
4022 PUBLIC RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
4023 RgSchCellCb             *cell;
4024 RgSchUeCb               *ue;
4025 RgSchDlSf               *subFrm;
4026 U8                      cqi;
4027 TfuDciFormat            dciFrmt;
4028 Bool                    isDtx;
4029 #endif
4030 {
4031    CmLteAggrLvl     aggrLvl;
4032    RgSchPdcchInfo   *pdcchInfo;
4033    RgSchPdcch       *pdcch;
4034
4035    TRC2(rgSCHCmnPdcchAlloc);
4036
4037    /* 3.1 consider the selected DCI format size in determining the
4038     * aggregation level */
4039    //TODO_SID Need to update. Currently using 4 aggregation level
4040    aggrLvl   = CM_LTE_AGGR_LVL2;//cellSch->dciAggrLvl[cqi][dciFrmt];
4041
4042 #ifdef LTE_ADV
4043    if((dciFrmt == TFU_DCI_FORMAT_1A) &&
4044       ((ue) && (ue->allocCmnUlPdcch)) )
4045    {
4046       pdcch = rgSCHCmnCmnPdcchAlloc(cell, subFrm);
4047       /* Since CRNTI Scrambled */
4048       if(NULLP != pdcch)
4049       {
4050          pdcch->dciNumOfBits = ue->dciSize.cmnSize[dciFrmt];
4051         // prc_trace_format_string(PRC_TRACE_GROUP_PS, PRC_TRACE_INFO_LOW,"Forcing alloc in CMN search spc size %d fmt %d \n",
4052         // pdcch->dciNumOfBits, dciFrmt);
4053       }
4054       RETVALUE(pdcch);
4055    }
4056 #endif
4057
4058    /* Incrementing aggrLvl by 1 if it not AGGR_LVL8(MAX SIZE)
4059     * inorder to increse the redudancy bits for better decoding of UE */
4060    if (isDtx)
4061    {
4062       if (aggrLvl != CM_LTE_AGGR_LVL16)
4063       {
4064          switch(aggrLvl)
4065          {
4066             case CM_LTE_AGGR_LVL2:
4067                aggrLvl = CM_LTE_AGGR_LVL4;
4068                 break;
4069             case CM_LTE_AGGR_LVL4:
4070                aggrLvl = CM_LTE_AGGR_LVL8;
4071                break;
4072             case CM_LTE_AGGR_LVL8:
4073                aggrLvl = CM_LTE_AGGR_LVL16;
4074                break;
4075             default:
4076                break;
4077          }
4078          /* aggrLvl   += 1; */
4079       }
4080    }
4081
4082    pdcchInfo = &subFrm->pdcchInfo;
4083
4084    /* Updating the no. of nCce in pdcchInfo, in case if CFI
4085     * was changed  */
4086 #ifdef LTE_TDD
4087    if(subFrm->nCce != pdcchInfo->nCce)
4088    {   
4089       rgSCHUtlPdcchInit(cell, subFrm, subFrm->nCce);
4090    }
4091 #else   
4092    if(cell->nCce != pdcchInfo->nCce)
4093    {
4094       rgSCHUtlPdcchInit(cell, subFrm, cell->nCce);
4095    }
4096 #endif       
4097
4098    if (pdcchInfo->nCce < (1 << (aggrLvl - 1)))
4099    {
4100       /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4101       subFrm->isCceFailure = TRUE;
4102       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4103             "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)", 
4104             aggrLvl);
4105
4106       RETVALUE(NULLP);
4107    }
4108
4109    if (rgSCHUtlPdcchAvail(cell, pdcchInfo, aggrLvl, &pdcch) == TRUE)
4110    {
4111       /* SR_RACH_STATS : Reset isTBMsg4 */
4112       pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4= FALSE;         
4113       pdcch->dci.u.format0Info.isSrGrant = FALSE;
4114 #ifdef LTEMAC_SPS
4115       pdcch->isSpsRnti = FALSE;
4116 #endif
4117       /* Increment the CCE used counter in the current subframe */
4118       subFrm->cceCnt += aggrLvl;
4119       pdcch->pdcchSearchSpace = RG_SCH_UE_SPECIFIC_SEARCH_SPACE;
4120       if (ue != NULLP)
4121                 {
4122 #ifdef LTE_ADV
4123                  if (ue->cell != cell)
4124                  {
4125                     /* Secondary Cell */
4126                     //pdcch->dciNumOfBits = ue->dciSize.noUlCcSize[dciFrmt];
4127                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4128                  }
4129                  else
4130 #endif
4131                  {
4132                     //pdcch->dciNumOfBits = ue->dciSize.dedSize[dciFrmt];
4133                     //TODO_SID Need to update dci size.
4134                     pdcch->dciNumOfBits = MAX_5GTF_DCIA1B1_SIZE;
4135                  }
4136                 }
4137       else
4138       {
4139          /* MSG4 */
4140          pdcch->dciNumOfBits = cell->dciSize.size[dciFrmt];
4141       }
4142       RETVALUE(pdcch);
4143    }
4144
4145    /* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
4146    subFrm->isCceFailure = TRUE;
4147
4148    RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
4149          "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
4150          aggrLvl);
4151    RETVALUE(NULLP);
4152 }
4153
4154 #ifdef RGR_V1
4155 /**
4156  * @brief This function implements BW allocation for CCCH SDU
4157  *
4158  * @details
4159  *
4160  *     Function: rgSCHCmnCcchSduDedAlloc
4161  *     Purpose:  Downlink bandwidth Allocation for CCCH SDU.
4162  *
4163  *     Invoked by: Scheduler
4164  *
4165  *  @param[in]  RgSchCellCb*     cell
4166  *  @param[out] RgSchUeCb        *ueCb
4167  *  @return S16
4168  *
4169  **/
4170 #ifdef ANSI
4171 PRIVATE S16 rgSCHCmnCcchSduDedAlloc
4172 (
4173 RgSchCellCb      *cell,
4174 RgSchUeCb        *ueCb
4175 )
4176 #else
4177 PRIVATE S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
4178 RgSchCellCb      *cell;
4179 RgSchUeCb        *ueCb;
4180 #endif
4181 {
4182    RgSchDlHqEnt      *hqE = NULLP;
4183    U32                  effBo;
4184    RgSchDlRbAlloc       *rbAllocinfo = NULLP;
4185    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4186    U8                   iTbs;
4187    U8                   numRb;
4188 #ifdef LTE_TDD
4189    U8                   cfi     = cellDl->currCfi;
4190 #endif
4191
4192    TRC2(rgSCHCmnCcchSduDedAlloc);
4193
4194    rbAllocinfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
4195
4196    effBo  =   ueCb->dlCcchInfo.bo + RGSCH_CCCH_SDU_HDRSIZE;
4197
4198 #ifndef LTEMAC_SPS
4199    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4200                       &rbAllocinfo->tbInfo[0].bytesReq,
4201                       &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4202 #else /* LTEMAC_SPS */
4203    rgSCHCmnClcRbAlloc(cell, effBo, cellDl->ccchCqi, &rbAllocinfo->rbsReq, \
4204                       &rbAllocinfo->tbInfo[0].bytesReq,\
4205                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE, 
4206                       rbAllocinfo->dlSf);
4207 #endif /* LTEMAC_SPS */
4208
4209    iTbs = 0;
4210    /* Cannot exceed the total number of RBs in the cell */
4211    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4212                                    rbAllocinfo->dlSf->bwAssigned)))
4213    {
4214       /* Check if atleast one allocation was possible.
4215          This may be the case where the Bw is very less and
4216          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4217       if (rbAllocinfo->dlSf->bwAssigned == 0)
4218       {
4219          numRb   = rbAllocinfo->dlSf->bw;
4220          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4221          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4222          {
4223             iTbs++;
4224          }
4225          rbAllocinfo->rbsReq = numRb;
4226          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4227          /* DwPTS Scheduling Changes Start */
4228 #ifdef LTE_TDD
4229          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4230          {
4231             rbAllocinfo->tbInfo[0].bytesReq =
4232                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1,cfi);
4233          }
4234 #endif
4235          /* DwPTS Scheduling Changes End */
4236          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4237       }
4238       else
4239       {
4240          RETVALUE(RFAILED);
4241       }
4242    }
4243
4244    /* Update the subframe Allocated BW field */
4245    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4246                                    rbAllocinfo->rbsReq;
4247    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
4248    rbAllocinfo->tbInfo[0].tbCb = &hqE->ccchSduProc->tbInfo[0];
4249    rbAllocinfo->rnti = ueCb->ueId;
4250    rbAllocinfo->tbInfo[0].noLyr = 1;
4251
4252    RETVALUE(ROK);
4253 }
4254 #endif
4255 \f
4256 /**
4257  * @brief This function implements BW allocation for MSG4
4258  *
4259  * @details
4260  *
4261  *     Function: rgSCHCmnMsg4DedAlloc
4262  *     Purpose:  Downlink bandwidth Allocation for MSG4.
4263  *
4264  *     Invoked by: Scheduler
4265  *
4266  *  @param[in]  RgSchCellCb*     cell
4267  *  @param[out] RgSchRaCb        *raCb
4268  *  @return S16
4269  *
4270  **/
4271 #ifdef ANSI
4272 PRIVATE S16 rgSCHCmnMsg4DedAlloc
4273 (
4274 RgSchCellCb      *cell,
4275 RgSchRaCb        *raCb
4276 )
4277 #else
4278 PRIVATE S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
4279 RgSchCellCb      *cell;
4280 RgSchRaCb        *raCb;
4281 #endif
4282 {
4283    U32                  effBo;
4284    RgSchDlRbAlloc       *rbAllocinfo = &raCb->rbAllocInfo;
4285    U8                   iTbs;
4286    U8                   numRb;
4287 #ifdef LTE_TDD
4288    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4289    U8                   cfi     = cellDl->currCfi;
4290 #endif
4291
4292    TRC2(rgSCHCmnMsg4DedAlloc);
4293
4294    effBo  = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
4295
4296 #ifndef LTEMAC_SPS
4297    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4298          &rbAllocinfo->tbInfo[0].bytesReq,\
4299          &rbAllocinfo->tbInfo[0].imcs, rbAllocinfo->dlSf);
4300 #else /* LTEMAC_SPS */
4301    rgSCHCmnClcRbAlloc(cell, effBo, raCb->ccchCqi, &rbAllocinfo->rbsReq, \
4302                       &rbAllocinfo->tbInfo[0].bytesReq,\
4303                       &rbAllocinfo->tbInfo[0].imcs, &iTbs, FALSE,
4304                       rbAllocinfo->dlSf);
4305 #endif /* LTEMAC_SPS */
4306
4307    iTbs = 0;
4308    /* Cannot exceed the total number of RBs in the cell */
4309    if ((S16)rbAllocinfo->rbsReq > ((S16)(rbAllocinfo->dlSf->bw - \
4310                rbAllocinfo->dlSf->bwAssigned)))
4311    {
4312       /* Check if atleast one allocation was possible.
4313          This may be the case where the Bw is very less and
4314          with the configured CCCH CQI, CCCH SDU exceeds the min Bw */
4315       if (rbAllocinfo->dlSf->bwAssigned == 0)
4316       {
4317          numRb   = rbAllocinfo->dlSf->bw;
4318          RG_SCH_CMN_DL_MCS_TO_TBS(rbAllocinfo->tbInfo[0].imcs, iTbs);
4319          while (rgTbSzTbl[0][++iTbs][numRb-1]/8 < effBo)
4320          {
4321             iTbs++;
4322          }
4323          rbAllocinfo->rbsReq = numRb;
4324          rbAllocinfo->tbInfo[0].bytesReq = rgTbSzTbl[0][iTbs][numRb-1]/8;
4325          /* DwPTS Scheduling Changes Start */
4326 #ifdef LTE_TDD
4327          if(rbAllocinfo->dlSf->sfType == RG_SCH_SPL_SF_DATA)
4328          {
4329             rbAllocinfo->tbInfo[0].bytesReq =
4330                rgSCHCmnCalcDwPtsTbSz(cell, effBo, &numRb, &iTbs, 1, cfi);
4331          }
4332 #endif
4333          /* DwPTS Scheduling Changes End */
4334          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, rbAllocinfo->tbInfo[0].imcs);
4335       }
4336       else
4337       {
4338          RETVALUE(RFAILED);
4339       }
4340    }
4341
4342    /* Update the subframe Allocated BW field */
4343    rbAllocinfo->dlSf->bwAssigned = rbAllocinfo->dlSf->bwAssigned + \
4344                                    rbAllocinfo->rbsReq;
4345    rbAllocinfo->rnti = raCb->tmpCrnti;
4346    rbAllocinfo->tbInfo[0].tbCb = &raCb->dlHqE->msg4Proc->tbInfo[0];
4347    rbAllocinfo->tbInfo[0].schdlngForTb = TRUE;
4348    rbAllocinfo->tbInfo[0].noLyr = 1;
4349
4350    RETVALUE(ROK);
4351 }
4352
4353 #ifdef LTE_TDD
4354 /**
4355  * @brief This function implements scheduling for RA Response.
4356  *
4357  * @details
4358  *
4359  *     Function: rgSCHCmnDlRaRsp
4360  *     Purpose:  Downlink scheduling for RA responses.
4361  *
4362  *     Invoked by: Scheduler
4363  *
4364  *  @param[in]  RgSchCellCb*     cell
4365  *  @return  Void
4366  *
4367  **/
4368 #ifdef ANSI
4369 PRIVATE Void rgSCHCmnDlRaRsp
4370 (
4371 RgSchCellCb                *cell,
4372 RgSchCmnDlRbAllocInfo      *allocInfo
4373 )
4374 #else
4375 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4376 RgSchCellCb                *cell;
4377 RgSchCmnDlRbAllocInfo      *allocInfo;
4378 #endif
4379 {
4380    CmLteTimingInfo      frm;
4381    CmLteTimingInfo      schFrm;
4382    RgSchDlSf            *subFrm;
4383    U16                  rarnti;
4384    U8                   i;
4385    U8                   noRaRnti=0;
4386    U8                   raIdx;
4387    RgSchTddRachRspLst   *rachRsp;
4388    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
4389    U8                   sfnIdx;
4390    U8                   subfrmIdx;
4391    U16                  rntiIdx=0;
4392    TRC2(rgSCHCmnDlRaRsp);
4393
4394    frm   = cell->crntTime;
4395    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4396
4397    /* Compute the subframe for which allocation is being made        */
4398    /* essentially, we need pointer to the dl frame for this subframe */
4399    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4400
4401    /* Get the RACH Response scheduling related information
4402     * for the subframe with RA index */
4403    raIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][frm.subframe]-1;
4404
4405    rachRsp = &cell->rachRspLst[raIdx];
4406
4407    for(sfnIdx = 0; sfnIdx < rachRsp->numRadiofrms; sfnIdx++)
4408    {
4409       /* For all scheduled RACH Responses in SFNs */
4410       schFrm = frm;
4411       RG_SCH_CMN_DECR_FRAME(schFrm.sfn, rachRsp->rachRsp[sfnIdx].sfnOffset);
4412       /* For all scheduled RACH Responses in subframes */
4413       for(subfrmIdx = 0;
4414             subfrmIdx < rachRsp->rachRsp[sfnIdx].numSubfrms; subfrmIdx++)
4415       {
4416          schFrm.subframe = rachRsp->rachRsp[sfnIdx].subframe[subfrmIdx];
4417          /* compute the last RA RNTI used in the previous subframe */
4418          raIdx = (((schFrm.sfn % cell->raInfo.maxRaSize) * \
4419                   RGSCH_NUM_SUB_FRAMES * RGSCH_MAX_RA_RNTI_PER_SUBFRM) \
4420                                     + schFrm.subframe);
4421
4422          /* For all RA RNTIs within a subframe */
4423
4424          for(i=0; (i < RGSCH_MAX_RA_RNTI_PER_SUBFRM) && \
4425                (noRaRnti < RGSCH_MAX_TDD_RA_RSP_ALLOC); i++)
4426          {
4427             rarnti = (schFrm.subframe + RGSCH_NUM_SUB_FRAMES*i + 1);
4428             rntiIdx = (raIdx + RGSCH_NUM_SUB_FRAMES*i);
4429
4430             if (cell->raInfo.raReqLst[rntiIdx].first != NULLP)
4431             {
4432                /* compute the next RA RNTI */
4433                if (rgSCHCmnRaRspAlloc(cell, subFrm, rntiIdx,
4434                         rarnti, noRaRnti, allocInfo) != ROK)
4435                {
4436                   /* The resources are exhausted */
4437                   break;
4438                }
4439                noRaRnti++;
4440             }
4441          }
4442          noRaRnti=0;
4443       }
4444    }
4445
4446    RETVOID;
4447 }
4448 #else
4449 /**
4450  * @brief This function implements scheduling for RA Response.
4451  *
4452  * @details
4453  *
4454  *     Function: rgSCHCmnDlRaRsp
4455  *     Purpose:  Downlink scheduling for RA responses.
4456  *
4457  *     Invoked by: Scheduler
4458  *
4459  *  @param[in]  RgSchCellCb*          cell
4460  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
4461  *  @return  Void
4462  *
4463  **/
4464 #ifdef ANSI
4465 PRIVATE Void rgSCHCmnDlRaRsp  //FDD
4466 (
4467 RgSchCellCb                *cell,
4468 RgSchCmnDlRbAllocInfo      *allocInfo
4469 )
4470 #else
4471 PRIVATE Void rgSCHCmnDlRaRsp(cell, allocInfo)
4472 RgSchCellCb                *cell;
4473 RgSchCmnDlRbAllocInfo      *allocInfo;
4474 #endif
4475 {
4476    CmLteTimingInfo      frm;
4477    CmLteTimingInfo      winStartFrm;
4478    RgSchDlSf            *subFrm;
4479    U8                   winStartIdx;
4480    U8                   winGap;
4481    U8                   rarnti;
4482    U8                   raIdx;
4483    RgSchCmnCell         *sched;
4484    U8                   i,noRaRnti=0;
4485    TRC2(rgSCHCmnDlRaRsp);
4486
4487    frm   = cell->crntTime;
4488    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
4489
4490    /* Compute the subframe for which allocation is being made        */
4491    /* essentially, we need pointer to the dl frame for this subframe */
4492    subFrm  = rgSCHUtlSubFrmGet(cell, frm);
4493    sched   = RG_SCH_CMN_GET_CELL(cell);
4494
4495    /* ccpu00132523 - Window Start calculated by considering RAR window size, 
4496     * RAR Wait period, Subframes occuppied for respective preamble format*/
4497    winGap = (sched->dl.numRaSubFrms-1) + (cell->rachCfg.raWinSize-1) 
4498              +RGSCH_RARSP_WAIT_PERIOD;
4499
4500    /* Window starting occassion is retrieved using the gap and tried to 
4501     * fit to the size of raReqLst array*/ 
4502    RGSCHDECRFRMCRNTTIME(frm, winStartFrm, winGap);
4503
4504         //5G_TODO TIMING update. Need to check
4505    winStartIdx = (winStartFrm.sfn & 1) * RGSCH_MAX_RA_RNTI+ winStartFrm.slot;
4506
4507    for(i = 0; ((i < cell->rachCfg.raWinSize) && (noRaRnti < RG_SCH_CMN_MAX_CMN_PDCCH)); i++)
4508    {
4509       raIdx = (winStartIdx + i) % RGSCH_RAREQ_ARRAY_SIZE;
4510
4511       if (cell->raInfo.raReqLst[raIdx].first != NULLP)
4512       {
4513          allocInfo->raRspAlloc[noRaRnti].biEstmt = \
4514                          (!i * RGSCH_ONE_BIHDR_SIZE);
4515          rarnti = raIdx % RGSCH_MAX_RA_RNTI+ 1;
4516          if (rgSCHCmnRaRspAlloc(cell, subFrm, raIdx,
4517                                  rarnti, noRaRnti, allocInfo) != ROK)
4518          {
4519             /* The resources are exhausted */
4520             break;
4521          }
4522          /* ccpu00132523- If all the RAP ids are not scheduled then need not 
4523           * proceed for next RA RNTIs*/
4524          if(allocInfo->raRspAlloc[noRaRnti].numRapids < cell->raInfo.raReqLst[raIdx].count)
4525          {
4526             break;
4527          }
4528          noRaRnti++; /* Max of RG_SCH_CMN_MAX_CMN_PDCCH RARNTIs
4529                         for response allocation */
4530       }
4531    }
4532    RETVOID;
4533 }
4534 #endif
4535
4536 \f
4537 /**
4538  * @brief This function allocates the resources for an RARNTI.
4539  *
4540  * @details
4541  *
4542  *     Function: rgSCHCmnRaRspAlloc
4543  *     Purpose:  Allocate resources to a RARNTI.
4544  *               0. Allocate PDCCH for sending the response.
4545  *               1. Locate the number of RA requests pending for the RARNTI.
4546  *               2. Compute the size of data to be built.
4547  *               3. Using common channel CQI, compute the number of RBs.
4548  *
4549  *     Invoked by: Scheduler
4550  *
4551  *  @param[in]  RgSchCellCb             *cell,
4552  *  @param[in]  RgSchDlSf               *subFrm,
4553  *  @param[in]  U16                     rarnti,
4554  *  @param[in]  U8                      noRaRnti
4555  *  @param[out] RgSchCmnDlRbAllocInfo   *allocInfo
4556  *  @return  S16
4557  *
4558  **/
4559 #ifdef ANSI
4560 PRIVATE S16 rgSCHCmnRaRspAlloc
4561 (
4562 RgSchCellCb             *cell,
4563 RgSchDlSf               *subFrm,
4564 U16                     raIndex,
4565 U16                     rarnti,
4566 U8                      noRaRnti,
4567 RgSchCmnDlRbAllocInfo   *allocInfo
4568 )
4569 #else
4570 PRIVATE S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
4571 RgSchCellCb             *cell;
4572 RgSchDlSf               *subFrm;
4573 U16                     raIndex;
4574 U16                     rarnti;
4575 U8                      noRaRnti;
4576 RgSchCmnDlRbAllocInfo   *allocInfo;
4577 #endif
4578 {
4579    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4580    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4581    U16                  noBytes;
4582    U32                  rb = 0;
4583    U32                  tbs;
4584    /*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
4585    U8                   mcs;
4586    CmLListCp            *reqLst;
4587    /* RACH handling related changes */
4588    Bool                 isAlloc = FALSE;
4589    static U8            schdNumRapid = 0;
4590    U8                   remNumRapid = 0;
4591    U8                   nPrb = 0;
4592    S32                  allwdTbSz = 0;
4593 #ifdef LTE_TDD   
4594    U16                  lostRe;  
4595    U8                   cfi = cellDl->currCfi;  
4596 #endif   
4597
4598    TRC2(rgSCHCmnRaRspAlloc);
4599 #ifndef RGR_V1
4600    UNUSED(cellUl);
4601 #endif
4602
4603    /* ccpu00132523: Resetting the schdRap Id count in every scheduling subframe*/
4604    if(noRaRnti == 0)
4605    {
4606       schdNumRapid = 0;
4607    }
4608
4609
4610    if (subFrm->bw == subFrm->bwAssigned)
4611    {
4612       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4613          "bw == bwAssigned RARNTI:%d",rarnti);
4614       RETVALUE(RFAILED);
4615    }
4616
4617    reqLst = &cell->raInfo.raReqLst[raIndex];
4618    if (reqLst->count == 0)
4619    {
4620       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4621          "reqLst Count=0 RARNTI:%d",rarnti);
4622       RETVALUE(RFAILED);
4623    }
4624    remNumRapid = reqLst->count;
4625
4626 #ifdef RGR_V1
4627    /* Limit number of rach rsps to maxMsg3PerUlsf */
4628    if ( schdNumRapid+remNumRapid > cellUl->maxMsg3PerUlSf )
4629    {
4630       remNumRapid = cellUl->maxMsg3PerUlSf-schdNumRapid;
4631    }
4632 #endif
4633  
4634    while (remNumRapid)
4635    {
4636       /* Try allocating for as many RAPIDs as possible */
4637       /* BI sub-header size to the tbSize requirement */
4638       noBytes  = RGSCH_GET_RAR_BYTES(remNumRapid) +\
4639                  allocInfo->raRspAlloc[noRaRnti].biEstmt;
4640       if ((allwdTbSz = rgSCHUtlGetAllwdCchTbSz(noBytes*8, &nPrb, &mcs)) == -1)
4641       {
4642          remNumRapid--;
4643          continue;
4644       }
4645
4646       /* rgSCHCmnClcRbAllocForFxdTb(cell, allwdTbSz/8, cellDl->ccchCqi, &rb);*/
4647       if(cellDl->bitsPerRb==0)
4648       {
4649          while ((rgTbSzTbl[0][0][rb]) <(U32) allwdTbSz)
4650          {
4651             rb++;
4652          }
4653          rb = rb+1;
4654       }
4655       else
4656       {
4657          rb = RGSCH_CEIL(allwdTbSz, cellDl->bitsPerRb);
4658       }
4659       /* DwPTS Scheduling Changes Start */      
4660 #ifdef LTE_TDD      
4661       if (subFrm->sfType == RG_SCH_SPL_SF_DATA)
4662       {
4663          RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
4664
4665          /* Calculate the less RE's because of DwPTS */
4666          lostRe = rb * (cellDl->noResPerRb[cfi] - 
4667                                   cellDl->numReDwPts[cfi]);
4668           
4669          /* Increase number of RBs in Spl SF to compensate for lost REs */
4670          rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]);
4671       }
4672 #endif      
4673       /* DwPTS Scheduling Changes End */
4674
4675       /*ccpu00115595- end*/
4676       if (rb > subFrm->bw - subFrm->bwAssigned)
4677       {
4678          remNumRapid--;
4679          continue;
4680       }
4681       /* Allocation succeeded for 'remNumRapid' */
4682       isAlloc = TRUE;
4683       tbs = allwdTbSz/8;
4684       printf("\n!!!RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
4685                                       noBytes,allwdTbSz,tbs,rb);
4686       break;
4687    }
4688    if (!isAlloc)
4689    {
4690       RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
4691       RETVALUE(RFAILED);
4692    }
4693
4694    subFrm->bwAssigned = subFrm->bwAssigned + rb;
4695
4696    /* Fill AllocInfo structure */
4697    allocInfo->raRspAlloc[noRaRnti].rnti = rarnti;
4698    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].bytesReq = tbs;
4699    allocInfo->raRspAlloc[noRaRnti].rbsReq = rb;
4700    allocInfo->raRspAlloc[noRaRnti].dlSf = subFrm;
4701    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].imcs = mcs;
4702    allocInfo->raRspAlloc[noRaRnti].raIndex = raIndex;
4703    /* RACH changes for multiple RAPID handling */
4704    allocInfo->raRspAlloc[noRaRnti].numRapids = remNumRapid;
4705    allocInfo->raRspAlloc[noRaRnti].nPrb = nPrb;
4706    allocInfo->raRspAlloc[noRaRnti].tbInfo[0].noLyr = 1;
4707    allocInfo->raRspAlloc[noRaRnti].vrbgReq = RGSCH_CEIL(nPrb,MAX_5GTF_VRBG_SIZE); 
4708    schdNumRapid += remNumRapid; 
4709    RETVALUE(ROK);
4710 }
4711
4712 /***********************************************************
4713  *
4714  *     Func : rgSCHCmnUlAllocFillRbInfo
4715  *
4716  *     Desc : Fills the start RB and the number of RBs for
4717  *            uplink allocation.
4718  *
4719  *     Ret  : void
4720  *
4721  *     Notes:
4722  *
4723  *     File :
4724  *
4725  **********************************************************/
4726 #ifdef ANSI
4727 PUBLIC Void rgSCHCmnUlAllocFillRbInfo
4728 (
4729 RgSchCellCb   *cell,
4730 RgSchUlSf      *sf,
4731 RgSchUlAlloc  *alloc
4732 )
4733 #else
4734 PUBLIC Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
4735 RgSchCellCb    *cell;
4736 RgSchUlSf      *sf;
4737 RgSchUlAlloc   *alloc;
4738 #endif
4739 {
4740     RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4741     RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4742     U8             cfi = cellDl->currCfi;
4743
4744
4745    TRC2(rgSCHCmnUlAllocFillRbInfo);
4746    alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) + 
4747                                     cell->dynCfiCb.bwInfo[cfi].startRb;
4748
4749    /* Num RBs = numSbAllocated * sbSize - less RBs in the last SB */
4750    alloc->grnt.numRb = (alloc->numSb * cellUl->sbSize);
4751
4752    RETVOID;
4753 }
4754
4755 /**
4756  * @brief Grant request for Msg3.
4757  *
4758  * @details
4759  *
4760  *     Function : rgSCHCmnMsg3GrntReq
4761  *
4762  *     This is invoked by downlink scheduler to request allocation
4763  *     for msg3.
4764  *     Steps:
4765  *     - Attempt to allocate msg3 in the current msg3 subframe
4766  *       Allocation attempt based on whether preamble is from group A
4767  *       and the value of MESSAGE_SIZE_GROUP_A
4768  *     - Link allocation with passed RNTI and msg3 HARQ process
4769  *     - Set the HARQ process ID (*hqProcIdRef)
4770  *
4771  *  @param[in]  RgSchCellCb       *cell
4772  *  @param[in]  CmLteRnti         rnti
4773  *  @param[in]  Bool              preamGrpA
4774  *  @param[in]  RgSchUlHqProcCb   *hqProc
4775  *  @param[out] RgSchUlAlloc      **ulAllocRef
4776  *  @param[out] U8                *hqProcIdRef
4777  *  @return  Void
4778  **/
4779 #ifdef ANSI
4780 PRIVATE Void rgSCHCmnMsg3GrntReq
4781 (
4782 RgSchCellCb     *cell,
4783 CmLteRnti       rnti,
4784 Bool            preamGrpA,
4785 RgSchUlHqProcCb *hqProc,
4786 RgSchUlAlloc    **ulAllocRef,
4787 U8              *hqProcIdRef
4788 )
4789 #else
4790 PRIVATE Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
4791                                  ulAllocRef, hqProcIdRef)
4792 RgSchCellCb     *cell;
4793 CmLteRnti       rnti;
4794 Bool            preamGrpA;
4795 RgSchUlHqProcCb *hqProc;
4796 RgSchUlAlloc    **ulAllocRef;
4797 U8              *hqProcIdRef;
4798 #endif
4799 {
4800    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
4801    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
4802    RgSchUlHole     *hole;
4803    RgSchUlAlloc    *alloc;
4804    U8              iMcs;
4805    U8              numSb;
4806
4807    TRC2(rgSCHCmnMsg3GrntReq);
4808
4809    *ulAllocRef = NULLP;
4810
4811    /* Fix: ccpu00120610 Use remAllocs from subframe during msg3 allocation */
4812    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
4813    {
4814       RETVOID;
4815    }
4816    if (preamGrpA == FALSE)
4817    {
4818       numSb = cellUl->ra.prmblBNumSb;
4819       iMcs  = cellUl->ra.prmblBIMcs;
4820    }
4821    else
4822    {
4823       numSb = cellUl->ra.prmblANumSb;
4824       iMcs  = cellUl->ra.prmblAIMcs;
4825    }
4826
4827    if ((hole = rgSCHUtlUlHoleFirst(sf)) != NULLP)
4828    {
4829       if(*sf->allocCountRef == 0)
4830       {
4831          RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
4832          /* Reinitialize the hole */
4833          if (sf->holeDb->count == 1 && (hole->start == 0)) /* Sanity check of holeDb */
4834          {
4835             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;
4836             /* Re-Initialize available subbands because of CFI change*/
4837             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
4838          }
4839          else
4840          {
4841             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
4842                      "Error! holeDb sanity check failed RNTI:%d",rnti);
4843          } 
4844       }
4845       if (numSb <= hole->num)
4846       {
4847          U8 iTbs;
4848          alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
4849          rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
4850          alloc->grnt.iMcs     = iMcs;
4851          alloc->grnt.iMcsCrnt = iMcs;
4852          iTbs                 = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
4853          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs); 
4854          /* To include the length and ModOrder in DataRecp Req.*/
4855          alloc->grnt.datSz = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
4856          RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
4857          /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
4858          alloc->grnt.nDmrs    = 0;
4859          alloc->grnt.hop      = 0;
4860          alloc->grnt.delayBit = 0;
4861          alloc->grnt.isRtx    = FALSE;
4862          *ulAllocRef          = alloc;
4863          *hqProcIdRef         = (cellUl->msg3SchdHqProcIdx);
4864          hqProc->procId       = *hqProcIdRef;
4865          hqProc->ulSfIdx      = (cellUl->msg3SchdIdx);
4866          alloc->rnti          = rnti;
4867          alloc->ue            = NULLP;
4868          alloc->pdcch         = FALSE;
4869          alloc->forMsg3       = TRUE;
4870          alloc->hqProc        = hqProc;
4871          rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
4872          //RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
4873          printf(
4874                "\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
4875                alloc->rnti,
4876                ((PTR)alloc->hqProc),
4877                alloc->hqProc->procId,
4878                alloc->hqProc->ulSfIdx);
4879          RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
4880                "alloc(%p)maxMsg3Tx(%d)",
4881                ((PTR)alloc),
4882                cell->rachCfg.maxMsg3Tx);
4883       }
4884    }
4885
4886    RETVOID;
4887 }
4888
4889 \f
4890 /**
4891  * @brief This function determines the allocation limits and
4892  *        parameters that aid in DL scheduling.
4893  *
4894  * @details
4895  *
4896  *     Function: rgSCHCmnDlSetUeAllocLmt
4897  *     Purpose:  This function determines the Maximum RBs
4898  *               a UE is eligible to get based on softbuffer
4899  *               limitation and cell->>>maxDlBwPerUe. The Codeword
4900  *               specific parameters like iTbs, eff and noLyrs
4901  *               are also set in this function. This function
4902  *               is called while UE configuration and UeDlCqiInd.
4903  *
4904  *     Invoked by: Scheduler
4905  *
4906  *  @param[in]  RgSchCellCb   *cellCb
4907  *  @param[in]  RgSchCmnDlUe  *ueDl
4908  *  @return  Void
4909  *
4910  **/
4911 #ifdef ANSI
4912 PRIVATE Void rgSCHCmnDlSetUeAllocLmt
4913 (
4914 RgSchCellCb   *cell,
4915 RgSchCmnDlUe  *ueDl,
4916 Bool          isEmtcUe
4917 )
4918 #else
4919 PRIVATE Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
4920 RgSchCellCb   *cell;
4921 RgSchCmnDlUe  *ueDl;
4922 Bool          isEmtcUe;
4923 #endif
4924 {
4925    U8            modOrder;
4926    U32           maxRb;
4927    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
4928    U8            cfi = cellSch->dl.currCfi;
4929
4930    TRC2(rgSCHCmnDlSetUeAllocLmt);
4931
4932 #ifdef EMTC_ENABLE
4933    if(TRUE == isEmtcUe)
4934    {
4935       /* ITbs for CW0 for 1 Layer Tx */
4936       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4937                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4938       /* ITbs for CW0 for 2 Layer Tx */
4939       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4940                                              [ueDl->mimoInfo.cwInfo[0].cqi];
4941       /* Eff for CW0 for 1 Layer Tx */
4942       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4943                                             [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4944       /* Eff for CW0 for 2 Layer Tx */
4945       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4946                                             [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4947
4948       /* ITbs for CW1 for 1 Layer Tx */
4949       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[0][cfi]))\
4950                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4951       /* ITbs for CW1 for 2 Layer Tx */
4952       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchEmtcCmnCqiToTbs *)(cellSch->dl.emtcCqiToTbsTbl[1][cfi]))\
4953                                              [ueDl->mimoInfo.cwInfo[1].cqi];
4954       /* Eff for CW1 for 1 Layer Tx */
4955       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4956                                             [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4957       /* Eff for CW1 for 2 Layer Tx */
4958       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4959                                             [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4960    }
4961    else
4962 #endif 
4963    {
4964       /* ITbs for CW0 for 1 Layer Tx */
4965       ueDl->mimoInfo.cwInfo[0].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4966                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4967       /* ITbs for CW0 for 2 Layer Tx */
4968       ueDl->mimoInfo.cwInfo[0].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4969                                          [ueDl->mimoInfo.cwInfo[0].cqi];
4970       /* Eff for CW0 for 1 Layer Tx */
4971       ueDl->mimoInfo.cwInfo[0].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4972                                         [ueDl->mimoInfo.cwInfo[0].iTbs[0]];
4973       /* Eff for CW0 for 2 Layer Tx */
4974       ueDl->mimoInfo.cwInfo[0].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4975                                         [ueDl->mimoInfo.cwInfo[0].iTbs[1]];
4976       
4977       /* ITbs for CW1 for 1 Layer Tx */
4978       ueDl->mimoInfo.cwInfo[1].iTbs[0] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
4979                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4980       /* ITbs for CW1 for 2 Layer Tx */
4981       ueDl->mimoInfo.cwInfo[1].iTbs[1] = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[1][cfi]))\
4982                                          [ueDl->mimoInfo.cwInfo[1].cqi];
4983       /* Eff for CW1 for 1 Layer Tx */
4984       ueDl->mimoInfo.cwInfo[1].eff[0] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]))\
4985                                         [ueDl->mimoInfo.cwInfo[1].iTbs[0]];
4986       /* Eff for CW1 for 2 Layer Tx */
4987       ueDl->mimoInfo.cwInfo[1].eff[1] = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
4988                                         [ueDl->mimoInfo.cwInfo[1].iTbs[1]];
4989    }
4990
4991 //#ifdef DL_LA 
4992   // ueDl->laCb.cqiBasediTbs =  ueDl->mimoInfo.cwInfo[0].iTbs[0] * 100;
4993 //#endif
4994    /* Assigning noLyrs to each CW assuming optimal Spatial multiplexing
4995     * capability */
4996    (ueDl->mimoInfo.ri/2 == 0)? (ueDl->mimoInfo.cwInfo[0].noLyr = 1) : \
4997               (ueDl->mimoInfo.cwInfo[0].noLyr = ueDl->mimoInfo.ri/2);
4998    ueDl->mimoInfo.cwInfo[1].noLyr = ueDl->mimoInfo.ri - ueDl->mimoInfo.cwInfo[0].noLyr;
4999    /* rg002.101:ccpu00102106: correcting DL harq softbuffer limitation logic.
5000     * The maxTbSz is the maximum number of PHY bits a harq process can
5001     * hold. Hence we limit our allocation per harq process based on this.
5002     * Earlier implementation we misinterpreted the maxTbSz to be per UE
5003     * per TTI, but in fact it is per Harq per TTI. */
5004    /* rg002.101:ccpu00102106: cannot exceed the harq Tb Size
5005     * and harq Soft Bits limit.*/
5006
5007    /* Considering iTbs corresponding to 2 layer transmission for
5008     * codeword0(approximation) and the maxLayers supported by
5009     * this UE at this point of time. */
5010    RG_SCH_CMN_TBS_TO_MODODR(ueDl->mimoInfo.cwInfo[0].iTbs[1], modOrder);
5011
5012    /* Bits/modOrder gives #REs, #REs/noResPerRb gives #RBs */
5013    /* rg001.301 -MOD- [ccpu00119213] : avoiding wraparound */
5014    maxRb = ((ueDl->maxSbSz)/(cellSch->dl.noResPerRb[cfi] * modOrder *\
5015                    ueDl->mimoInfo.ri));
5016    if (cellSch->dl.isDlFreqSel)
5017    {
5018       /* Rounding off to left nearest multiple of RBG size */
5019       maxRb -= maxRb % cell->rbgSize;
5020    }
5021    ueDl->maxRb = RGSCH_MIN(maxRb, cellSch->dl.maxDlBwPerUe);
5022    if (cellSch->dl.isDlFreqSel)
5023    {
5024       /* Rounding off to right nearest multiple of RBG size */
5025       if (ueDl->maxRb % cell->rbgSize)
5026       {
5027          ueDl->maxRb += (cell->rbgSize - 
5028                          (ueDl->maxRb % cell->rbgSize));
5029       }
5030    }
5031
5032    /* Set the index of the cwInfo, which is better in terms of
5033     * efficiency. If RI<2, only 1 CW, hence btrCwIdx shall be 0 */
5034    if (ueDl->mimoInfo.ri < 2)
5035    {
5036       ueDl->mimoInfo.btrCwIdx = 0;
5037    }
5038    else
5039    {
5040       if (ueDl->mimoInfo.cwInfo[0].eff[ueDl->mimoInfo.cwInfo[0].noLyr-1] <\
5041           ueDl->mimoInfo.cwInfo[1].eff[ueDl->mimoInfo.cwInfo[1].noLyr-1])
5042       {
5043          ueDl->mimoInfo.btrCwIdx = 1;
5044       }
5045       else
5046       {
5047          ueDl->mimoInfo.btrCwIdx = 0;
5048       }
5049    }
5050
5051    RETVOID;
5052    }
5053
5054 #ifdef DL_LA
5055
5056 /**
5057  * @brief This function updates TX Scheme.
5058  *
5059  * @details
5060  *
5061  *     Function: rgSCHCheckAndSetTxScheme 
5062  *     Purpose:  This function determines the Maximum RBs
5063  *               a UE is eligible to get based on softbuffer
5064  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5065  *               specific parameters like iTbs, eff and noLyrs
5066  *               are also set in this function. This function
5067  *               is called while UE configuration and UeDlCqiInd.
5068  *
5069  *     Invoked by: Scheduler
5070  *
5071  *  @param[in]  RgSchCellCb   *cell
5072  *  @param[in]  RgSchUeCb     *ue
5073  *  @return  Void
5074  *
5075  **/
5076 #ifdef ANSI
5077 PRIVATE Void rgSCHCheckAndSetTxScheme 
5078 (
5079 RgSchCellCb   *cell,
5080 RgSchUeCb     *ue
5081 )
5082 #else
5083 PRIVATE Void rgSCHCheckAndSetTxScheme(cell, ue)
5084 RgSchCellCb   *cell;
5085 RgSchUeCb     *ue;
5086 #endif
5087 {
5088    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5089    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue ,cell);
5090    U8            cfi = cellSch->dl.currCfi;
5091    U8            maxiTbs;
5092    U8            cqiBasediTbs;
5093    U8            actualiTbs;
5094
5095    TRC2(rgSCHCheckAndSetTxScheme);
5096
5097    maxiTbs      = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
5098                 [RG_SCH_CMN_MAX_CQI - 1];
5099    cqiBasediTbs = (ueDl->laCb[0].cqiBasediTbs)/100;
5100    actualiTbs   = ueDl->mimoInfo.cwInfo[0].iTbs[0];
5101
5102    if((actualiTbs < RG_SCH_TXSCHEME_CHNG_ITBS_FACTOR) && (cqiBasediTbs >
5103      actualiTbs) && ((cqiBasediTbs - actualiTbs) > RG_SCH_TXSCHEME_CHNG_THRSHD)) 
5104    {
5105       RG_SCH_CMN_SET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5106    }
5107    
5108    if(actualiTbs >= maxiTbs)
5109    {
5110       RG_SCH_CMN_UNSET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
5111    }
5112
5113    RETVOID;
5114 }
5115
5116 /**
5117  * @brief This function determines the allocation limits and
5118  *        parameters that aid in DL scheduling.
5119  *
5120  * @details
5121  *
5122  *     Function: rgSCHCmnDlSetUeAllocLmtLa
5123  *     Purpose:  This function determines the Maximum RBs
5124  *               a UE is eligible to get based on softbuffer
5125  *               limitation and cell->>>maxDlBwPerUe. The Codeword
5126  *               specific parameters like iTbs, eff and noLyrs
5127  *               are also set in this function. This function
5128  *               is called while UE configuration and UeDlCqiInd.
5129  *
5130  *     Invoked by: Scheduler
5131  *
5132  *  @param[in]  RgSchCellCb   *cell
5133  *  @param[in]  RgSchUeCb     *ue
5134  *  @return  Void
5135  *
5136  **/
5137 #ifdef ANSI
5138 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa
5139 (
5140 RgSchCellCb   *cell,
5141 RgSchUeCb     *ue
5142 )
5143 #else
5144 PUBLIC Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
5145 RgSchCellCb   *cell;
5146 RgSchUeCb     *ue;
5147 #endif
5148 {
5149    U8            modOrder;
5150    U32           maxRb;
5151    U8            reportediTbs;
5152    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
5153    RgSchCmnDlUe  *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
5154    U8            cfi = cellSch->dl.currCfi;
5155    U8            maxiTbs;
5156    U8            cwIdx = 0; 
5157
5158    TRC2(rgSCHCmnDlSetUeAllocLmtLa);
5159
5160    maxiTbs      = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
5161    if(ueDl->cqiFlag == TRUE)
5162    {
5163       for(cwIdx=0; cwIdx < RG_SCH_CMN_MAX_CW_PER_UE; cwIdx++)
5164       {
5165          S32 iTbsNew;
5166
5167          /* Calcluating the reported iTbs for code word 0 */
5168          reportediTbs = ue->ue5gtfCb.mcs; 
5169
5170          iTbsNew = (S32) reportediTbs;
5171
5172          if(!ueDl->laCb[cwIdx].notFirstCqi)
5173          {
5174             /* This is the first CQI report from UE */
5175             ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5176             ueDl->laCb[cwIdx].notFirstCqi  =  TRUE;
5177          }
5178          else if ((RG_ITBS_DIFF(reportediTbs, ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0])) > 5)
5179          {
5180             /* Ignore this iTBS report and mark that last iTBS report was */
5181             /* ignored so that subsequently we reset the LA algorithm     */
5182             ueDl->laCb[cwIdx].lastiTbsIgnored = TRUE;
5183             ueDl->laCb[cwIdx].numLastiTbsIgnored++;
5184             if( ueDl->laCb[cwIdx].numLastiTbsIgnored > 10)
5185             {
5186                /* CQI reported by UE is not catching up. Reset the LA algorithm */
5187                ueDl->laCb[cwIdx].cqiBasediTbs = (iTbsNew * 100);
5188                ueDl->laCb[cwIdx].deltaiTbs = 0;
5189                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5190                ueDl->laCb[cwIdx].numLastiTbsIgnored = 0;
5191             }
5192          }
5193          else
5194          {
5195             if (ueDl->laCb[cwIdx].lastiTbsIgnored != TRUE)
5196             {
5197                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5198                      (80 * ueDl->laCb[cwIdx].cqiBasediTbs))/100;
5199             }
5200             else
5201             {
5202                /* Reset the LA as iTbs in use caught up with the value   */
5203                /* reported by UE.                                        */
5204                ueDl->laCb[cwIdx].cqiBasediTbs = ((20 * iTbsNew * 100) +
5205                      (80 * ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] * 100))/100;
5206                ueDl->laCb[cwIdx].deltaiTbs = 0;
5207                ueDl->laCb[cwIdx].lastiTbsIgnored = FALSE;
5208             }
5209          }
5210
5211          iTbsNew = (ueDl->laCb[cwIdx].cqiBasediTbs + ueDl->laCb[cwIdx].deltaiTbs)/100;
5212
5213          RG_SCH_CHK_ITBS_RANGE(iTbsNew, maxiTbs);       
5214
5215          ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0] = RGSCH_MIN(iTbsNew, cell->thresholds.maxDlItbs);
5216          //ueDl->mimoInfo.cwInfo[cwIdx].iTbs[1] = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5217 #ifdef RG_5GTF
5218          ue->ue5gtfCb.mcs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
5219          /*
5220          printf("reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n", 
5221                  reportediTbs, ueDl->laCb[cwIdx].cqiBasediTbs, ueDl->laCb[cwIdx].deltaiTbs,
5222                  iTbsNew, ue->ue5gtfCb.mcs, cwIdx);
5223          */
5224 #endif
5225
5226          if((ue->mimoInfo.txMode != RGR_UE_TM_3) && (ue->mimoInfo.txMode != RGR_UE_TM_4))
5227          {
5228             break; 
5229          }
5230       }
5231       ueDl->cqiFlag = FALSE;
5232    } 
5233
5234
5235    RETVOID;
5236 }
5237 #endif
5238 /***********************************************************
5239  *
5240  *     Func : rgSCHCmnDlUeResetTemp
5241  *
5242  *     Desc : Reset whatever variables where temporarily used
5243  *            during UE scheduling.
5244  *
5245  *     Ret  : Void
5246  *
5247  *     Notes:
5248  *
5249  *     File :
5250  *
5251  **********************************************************/
5252 #ifdef ANSI
5253 PUBLIC Void rgSCHCmnDlHqPResetTemp 
5254 (
5255 RgSchDlHqProcCb         *hqP
5256 )
5257 #else
5258 PUBLIC Void rgSCHCmnDlHqPResetTemp(hqP)
5259 RgSchDlHqProcCb         *hqP;
5260 #endif
5261 {
5262
5263    TRC2(rgSCHCmnDlHqPResetTemp);
5264
5265    /* Fix: syed having a hqP added to Lists for RB assignment rather than
5266     * a UE, as adding UE was limiting handling some scenarios */ 
5267     hqP->reqLnk.node = (PTR)NULLP;
5268     hqP->schdLstLnk.node = (PTR)NULLP;
5269
5270    RETVOID;
5271 }  /* rgSCHCmnDlHqPResetTemp */
5272
5273 /***********************************************************
5274  *
5275  *     Func : rgSCHCmnDlUeResetTemp
5276  *
5277  *     Desc : Reset whatever variables where temporarily used
5278  *            during UE scheduling.
5279  *
5280  *     Ret  : Void
5281  *
5282  *     Notes:
5283  *
5284  *     File :
5285  *
5286  **********************************************************/
5287 #ifdef ANSI
5288 PUBLIC Void rgSCHCmnDlUeResetTemp
5289 (
5290 RgSchUeCb               *ue,
5291 RgSchDlHqProcCb         *hqP
5292 )
5293 #else
5294 PUBLIC Void rgSCHCmnDlUeResetTemp(ue, hqP)
5295 RgSchUeCb               *ue;
5296 RgSchDlHqProcCb         *hqP;
5297 #endif
5298 {
5299    RgSchDlRbAlloc  *allocInfo;
5300    RgSchCmnDlUe       *cmnUe = RG_SCH_CMN_GET_DL_UE(ue,hqP->hqE->cell);
5301 #ifdef LTE_ADV
5302    Void           *tmpCb;
5303 #endif
5304
5305    TRC2(rgSCHCmnDlUeResetTemp);
5306
5307    /* Fix : syed check for UE's existence was useless.
5308     * Instead we need to check that reset is done only for the 
5309     * information of a scheduled harq proc, which is cmnUe->proc.
5310     * Reset should not be done for non-scheduled hqP */
5311    if((cmnUe->proc == hqP) || (cmnUe->proc == NULLP))
5312    {
5313       cmnUe->proc = NULLP;
5314       allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, hqP->hqE->cell);
5315 #ifdef LTE_ADV
5316       tmpCb = allocInfo->laaCb;
5317 #endif
5318       cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
5319       allocInfo->rnti = ue->ueId;
5320 #ifdef LTE_ADV
5321       allocInfo->laaCb = tmpCb;
5322 #endif
5323       /* Fix: syed moving this to a common function for both scheduled
5324        * and non-scheduled UEs */
5325       cmnUe->outStndAlloc = 0;
5326    }
5327    rgSCHCmnDlHqPResetTemp(hqP);
5328
5329    RETVOID;
5330 }  /* rgSCHCmnDlUeResetTemp */
5331
5332 /***********************************************************
5333  *
5334  *     Func : rgSCHCmnUlUeResetTemp
5335  *
5336  *     Desc : Reset whatever variables where temporarily used
5337  *            during UE scheduling.
5338  *
5339  *     Ret  : Void
5340  *
5341  *     Notes:
5342  *
5343  *     File :
5344  *
5345  **********************************************************/
5346 #ifdef ANSI
5347 PUBLIC Void rgSCHCmnUlUeResetTemp
5348 (
5349 RgSchCellCb             *cell,
5350 RgSchUeCb               *ue
5351 )
5352 #else
5353 PUBLIC Void rgSCHCmnUlUeResetTemp(cell, ue)
5354 RgSchCellCb             *cell;
5355 RgSchUeCb               *ue;
5356 #endif
5357 {
5358    RgSchCmnUlUe       *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
5359
5360    TRC2(rgSCHCmnUlUeResetTemp);
5361
5362    cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
5363
5364    RETVOID;
5365 }  /* rgSCHCmnUlUeResetTemp */
5366
5367
5368 \f
5369 /**
5370  * @brief This function fills the PDCCH information from dlProc.
5371  *
5372  * @details
5373  *
5374  *     Function: rgSCHCmnFillPdcch
5375  *     Purpose:  This function fills in the PDCCH information
5376  *               obtained from the RgSchDlRbAlloc
5377  *               during common channel scheduling(P, SI, RA - RNTI's).
5378  *
5379  *     Invoked by: Downlink Scheduler
5380  *
5381  *  @param[out] RgSchPdcch*       pdcch
5382  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5383  *  @return  Void
5384  *
5385  **/
5386 #ifdef ANSI
5387 PUBLIC Void rgSCHCmnFillPdcch
5388 (
5389 RgSchCellCb                *cell,
5390 RgSchPdcch                 *pdcch,
5391 RgSchDlRbAlloc             *rbAllocInfo
5392 )
5393 #else
5394 PUBLIC Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
5395 RgSchCellCb                *cell;
5396 RgSchPdcch                 *pdcch;
5397 RgSchDlRbAlloc             *rbAllocInfo;
5398 #endif
5399 {
5400
5401    TRC2(rgSCHCmnFillPdcch);
5402
5403    /* common channel pdcch filling,
5404     * only 1A and Local is supported */
5405    pdcch->rnti                       = rbAllocInfo->rnti;
5406    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
5407    switch(rbAllocInfo->dciFormat)
5408    {
5409 #ifdef RG_5GTF  /* ANOOP: ToDo: DCI format B1/B2 filling */
5410       case TFU_DCI_FORMAT_B1:
5411          {
5412             /* ToDo: Anoop */
5413             pdcch->dci.u.formatB1Info.formatType = 0;
5414             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].cmnGrnt.xPDSCHRange;
5415             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].cmnGrnt.rbAssign;
5416             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = 0;
5417             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5418             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = 0;
5419             //pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].ndi;
5420             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].cmnGrnt.rv;
5421             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5422             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5423             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5424             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5425             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5426             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5427             //TODO_SID: Need to update
5428             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5429             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5430             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5431             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5432             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5433             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
5434             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].cmnGrnt.SCID;
5435             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
5436             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
5437             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
5438
5439             break; /* case TFU_DCI_FORMAT_B1: */
5440          }
5441
5442       case TFU_DCI_FORMAT_B2:
5443          {
5444             //printf(" RG_5GTF:: Pdcch filling with DCI format B2\n");
5445             /* ToDo: Anoop */
5446             break; /* case TFU_DCI_FORMAT_B2: */
5447          }
5448 #endif
5449       case TFU_DCI_FORMAT_1A:
5450          pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
5451
5452          /*Nprb indication at PHY for common Ch
5453           *setting least significant bit of tpc field to 1 if
5454           nPrb=3 and 0 otherwise. */
5455          if (rbAllocInfo->nPrb == 3)
5456          {
5457             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 1;
5458          }
5459          else
5460          {
5461             pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = 0;
5462          }
5463          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
5464          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
5465          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
5466                                                                    rbAllocInfo->tbInfo[0].imcs;
5467          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = 0;
5468          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = 0;
5469          /* Add RIV CALC */
5470          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
5471             TFU_ALLOC_TYPE_RIV;
5472          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
5473             rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
5474                   rbAllocInfo->allocInfo.raType2.rbStart,
5475                   rbAllocInfo->allocInfo.raType2.numRb);
5476
5477 #ifdef LTE_TDD
5478          pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = \
5479                                                                            FALSE;
5480 #ifdef TFU_TDD
5481          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
5482          pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
5483 #endif
5484 #endif
5485          break; /* case TFU_DCI_FORMAT_1A: */
5486       case TFU_DCI_FORMAT_1:
5487          pdcch->dci.u.format1Info.tpcCmd = 0;
5488          /* Avoiding this check,as we dont support Type1 RA */
5489 #ifdef RG_UNUSED
5490          if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
5491          {
5492 #endif
5493             pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
5494             pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
5495                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
5496                 & 0xff);
5497             pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
5498                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
5499                 & 0x00ff);
5500             pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
5501                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
5502                 & 0x0000ff);
5503             pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
5504                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
5505 #ifdef RG_UNUSED
5506          }
5507 #endif
5508          pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
5509          pdcch->dci.u.format1Info.allocInfo.ndi = 0;
5510          pdcch->dci.u.format1Info.allocInfo.mcs = rbAllocInfo->tbInfo[0].imcs;
5511          pdcch->dci.u.format1Info.allocInfo.rv = 0;
5512 #ifdef TFU_TDD
5513          pdcch->dci.u.format1Info.dai = 1;
5514 #endif
5515          break;
5516       default:
5517          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Allocator's icorrect "
5518             "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
5519          break;
5520    }
5521    RETVOID;
5522 }
5523
5524 #ifdef LTE_TDD
5525 /**
5526  * @brief This function finds whether the subframe is special subframe or not.
5527  *
5528  * @details
5529  *
5530  *     Function: rgSCHCmnIsSplSubfrm
5531  *     Purpose:  This function finds the subframe index of the special subframe
5532  *               and finds whether the current DL index matches it or not.
5533  *
5534  *     Invoked by: Scheduler
5535  *
5536  *  @param[in] U8                   splfrmCnt
5537  *  @param[in] U8                   curSubfrmIdx
5538  *  @param[in] U8                   periodicity
5539  *  @param[in] RgSchTddSubfrmInfo   *subfrmInfo
5540  *  @return  Bool
5541  *
5542  **/
5543 #ifdef ANSI
5544 PRIVATE Bool rgSCHCmnIsSplSubfrm
5545 (
5546 U8                   splfrmCnt,
5547 U8                   curSubfrmIdx,
5548 U8                   periodicity,
5549 RgSchTddSubfrmInfo   *subfrmInfo
5550 )
5551 #else
5552 PRIVATE Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
5553 U8                   splfrmCnt;
5554 U8                   curSubfrmIdx;
5555 U8                   periodicity;
5556 RgSchTddSubfrmInfo   *subfrmInfo;
5557 #endif
5558 {
5559    U8 dlSfCnt = 0;
5560    U8 splfrmIdx  = 0;
5561
5562    TRC2(rgSCHCmnIsSplSubfrm);
5563
5564    if(splfrmCnt > 0)
5565    {
5566       if(periodicity == RG_SCH_CMN_5_MS_PRD)
5567       {
5568          if(splfrmCnt%2)
5569          {
5570             dlSfCnt = ((splfrmCnt-1)/2) *\
5571                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5572             dlSfCnt = dlSfCnt + subfrmInfo->numFrmHf1;
5573          }
5574          else
5575          {
5576             dlSfCnt = (splfrmCnt/2) * \
5577                       (subfrmInfo->numFrmHf1 + subfrmInfo->numFrmHf2);
5578          }
5579       }
5580       else
5581       {
5582          dlSfCnt = splfrmCnt * subfrmInfo->numFrmHf1;
5583       }
5584       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1 +\
5585                   (periodicity*splfrmCnt - dlSfCnt);
5586    }
5587    else
5588    {
5589       splfrmIdx = RG_SCH_CMN_SPL_SUBFRM_1;
5590    }
5591
5592    if(splfrmIdx == curSubfrmIdx)
5593    {
5594       RETVALUE(TRUE);
5595    }
5596
5597    RETVALUE(FALSE);
5598 }
5599
5600 /**
5601  * @brief This function updates DAI or UL index.
5602  *
5603  * @details
5604  *
5605  *     Function: rgSCHCmnUpdHqAndDai
5606  *     Purpose:  Updates the DAI based on UL-DL Configuration
5607  *               index and UE. It also updates the HARQ feedback
5608  *               time and 'm' index.
5609  *
5610  *     Invoked by: TOM
5611  *
5612  *  @param[in]  RgDlHqProcCb  *hqP
5613  *  @param[in]  RgSchDlSf     *subFrm
5614  *  @param[in]  RgSchDlHqTbCb *tbCb
5615  *  @param[in]  U8            tbAllocIdx
5616  *  @return  Void
5617  *
5618  **/
5619 #ifdef ANSI
5620 PRIVATE Void rgSCHCmnUpdHqAndDai
5621 (
5622 RgSchDlHqProcCb   *hqP,
5623 RgSchDlSf         *subFrm,
5624 RgSchDlHqTbCb     *tbCb,
5625 U8                tbAllocIdx
5626 )
5627 #else
5628 PRIVATE Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
5629 RgSchDlHqProcCb   *hqP;
5630 RgSchDlSf         *subFrm;
5631 RgSchDlHqTbCb     *tbCb;
5632 U8                tbAllocIdx;
5633 #endif
5634 {
5635    RgSchUeCb      *ue = hqP->hqE->ue;
5636    
5637    TRC2(rgSCHCmnUpdHqAndDai);
5638
5639    if(subFrm != NULLP)
5640    {
5641       /* set the time at which UE shall send the feedback
5642        * for this process */
5643       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5644             subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5645       tbCb->fdbkTime.subframe = subFrm->dlFdbkInfo.subframe;
5646       tbCb->m = subFrm->dlFdbkInfo.m;
5647    }
5648    else
5649    {
5650       /* set the time at which UE shall send the feedback
5651        * for this process */
5652       tbCb->fdbkTime.sfn = (tbCb->timingInfo.sfn + \
5653             hqP->subFrm->dlFdbkInfo.sfnOffset) % RGSCH_MAX_SFN;
5654       tbCb->fdbkTime.subframe = hqP->subFrm->dlFdbkInfo.subframe;
5655       tbCb->m = hqP->subFrm->dlFdbkInfo.m;
5656    }
5657
5658    /* ccpu00132340-MOD- DAI need to be updated for first TB only*/
5659    if(ue && !tbAllocIdx)
5660    {
5661       Bool   havePdcch = (tbCb->hqP->pdcch ? TRUE : FALSE);
5662       U8     dlDai;
5663       
5664       dlDai = rgSCHCmnUpdDai(ue, &tbCb->fdbkTime, tbCb->m, havePdcch,tbCb->hqP,
5665             &tbCb->dai);
5666       if(havePdcch)
5667       {/* Non SPS occasions */
5668          tbCb->hqP->pdcch->dlDai = dlDai;
5669          /* hqP->ulDai is used for N1 resource filling
5670           * when SPS occaions present in a bundle */
5671          tbCb->hqP->ulDai = tbCb->dai;
5672          tbCb->hqP->dlDai = dlDai;
5673       }
5674    }
5675
5676    /* Updatijng pucchFdbkIdx for both PUCCH or PUSCH
5677       fdbk reception */
5678    tbCb->pucchFdbkIdx = tbCb->hqP->ulDai;
5679
5680    RETVOID;
5681 }
5682
5683
5684 /**
5685  * @brief This function updates DAI or UL index.
5686  *
5687  * @details
5688  *
5689  *     Function: rgSCHCmnUpdDai
5690  *     Purpose:  Updates the DAI in the ack-nack info, a valid
5691  *               ue should be passed
5692  *
5693  *     Invoked by: TOM
5694  *
5695  *  @param[in]  RgDlHqProcCb  *hqP
5696  *  @param[in]  RgSchDlSf     *subFrm
5697  *  @param[in]  RgSchDlHqTbCb *tbCb
5698  *  @return  U8 dlDai 
5699  *
5700  **/
5701 #ifdef ANSI
5702 PUBLIC U8 rgSCHCmnUpdDai
5703 (
5704 RgSchUeCb         *ue,
5705 CmLteTimingInfo   *fdbkTime,
5706 U8                 m,
5707 Bool               havePdcch,
5708 RgSchDlHqProcCb   *hqP,
5709 U8                *ulDai
5710 )
5711 #else
5712 PUBLIC U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
5713 RgSchUeCb         *ue;
5714 CmLteTimingInfo   *fdbkTime;
5715 U8                 m;
5716 Bool               havePdcch;
5717 RgSchDlHqProcCb   *hqP;
5718 U8                *ulDai;
5719 #endif
5720 {
5721    RgSchTddANInfo *anInfo;
5722    U8             servCellIdx;
5723    U8             ackNackFdbkArrSize;
5724   
5725
5726    TRC2(rgSCHCmnUpdDai);
5727
5728    if(hqP != NULLP)
5729    {/* Non SPS */
5730 #ifdef LTE_ADV
5731       servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
5732             hqP->hqE->cell->cellId,
5733             ue);
5734 #else
5735      servCellIdx = RGSCH_PCELL_INDEX;
5736 #endif
5737       ackNackFdbkArrSize = hqP->hqE->cell->ackNackFdbkArrSize;
5738    }else
5739    {/* SPS on primary cell */
5740       servCellIdx = RGSCH_PCELL_INDEX;
5741       ackNackFdbkArrSize = ue->cell->ackNackFdbkArrSize;
5742    }
5743
5744
5745    anInfo = rgSCHUtlGetUeANFdbkInfo(ue, fdbkTime,servCellIdx);
5746
5747    /* If no ACK/NACK feedback already present, create a new one */
5748    if(NULLP == anInfo)
5749    {
5750       anInfo = &ue->cellInfo[servCellIdx]->anInfo[ue->cellInfo[servCellIdx]->nextFreeANIdx];
5751       anInfo->sfn = fdbkTime->sfn;
5752       anInfo->subframe = fdbkTime->subframe;
5753       anInfo->latestMIdx = m;
5754       /* Fixing DAI value - ccpu00109162 */
5755       /* Handle TDD case as in MIMO definition of the function */
5756       anInfo->ulDai = 1;
5757       if (havePdcch)
5758       {
5759          anInfo->dlDai = 1;
5760       }
5761       anInfo->isSpsOccasion = FALSE;
5762       /* set the free Index to store  Ack/Nack Information*/
5763       ue->cellInfo[servCellIdx]->nextFreeANIdx = (ue->cellInfo[servCellIdx]->nextFreeANIdx + 1) %
5764          ackNackFdbkArrSize;
5765
5766    }
5767    else
5768    {
5769       anInfo->latestMIdx = m;
5770       /* Fixing DAI value - ccpu00109162 */
5771       /* Handle TDD case as in MIMO definition of the function */
5772       anInfo->ulDai = anInfo->ulDai + 1;
5773       if (havePdcch)
5774       {
5775          anInfo->dlDai = anInfo->dlDai + 1;
5776       }
5777    }
5778 #ifdef LTE_ADV
5779    /* ignoring the Scell check,
5780     * for primary cell this field is unused*/
5781    if(hqP != NULLP)
5782    {/* SPS*/
5783       anInfo->n1ResTpcIdx = hqP->tpc;
5784    }
5785
5786    if(ulDai)
5787    {/* As this not required for release pdcch */
5788       *ulDai = anInfo->ulDai;
5789    }
5790 #endif
5791    RETVALUE(anInfo->dlDai);
5792
5793 }
5794 #endif /* ifdef LTE_TDD */
5795
5796 PUBLIC U32 rgHqRvRetxCnt[4][2];
5797 PUBLIC U32 rgUlrate_grant;
5798
5799 /**
5800  * @brief This function fills the HqP TB with rbAllocInfo.
5801  *
5802  * @details
5803  *
5804  *     Function: rgSCHCmnFillHqPTb
5805  *     Purpose:  This function fills in the HqP TB with rbAllocInfo.
5806  *
5807  *     Invoked by: rgSCHCmnFillHqPTb
5808  *
5809  *  @param[in]  RgSchCellCb*      cell
5810  *  @param[in]  RgSchDlRbAlloc    *rbAllocInfo,
5811  *  @param[in]  U8                tbAllocIdx
5812  *  @param[in]  RgSchPdcch        *pdcch
5813  *  @return  Void
5814  *
5815  **/
5816 #ifdef LTEMAC_SPS
5817 #ifdef ANSI
5818 PUBLIC Void rgSCHCmnFillHqPTb
5819 (
5820 RgSchCellCb                *cell,
5821 RgSchDlRbAlloc             *rbAllocInfo,
5822 U8                         tbAllocIdx,
5823 RgSchPdcch                 *pdcch
5824 )
5825 #else
5826 PUBLIC Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5827 RgSchCellCb                *cell;
5828 RgSchDlRbAlloc             *rbAllocInfo;
5829 U8                         tbAllocIdx;
5830 RgSchPdcch                 *pdcch;
5831 #endif
5832 #else
5833 #ifdef ANSI
5834 PRIVATE Void rgSCHCmnFillHqPTb
5835 (
5836 RgSchCellCb                *cell,
5837 RgSchDlRbAlloc             *rbAllocInfo,
5838 U8                         tbAllocIdx,
5839 RgSchPdcch                 *pdcch
5840 )
5841 #else
5842 PRIVATE Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
5843 RgSchCellCb                *cell;
5844 RgSchDlRbAlloc             *rbAllocInfo;
5845 U8                         tbAllocIdx;
5846 RgSchPdcch                 *pdcch;
5847 #endif
5848 #endif /* LTEMAC_SPS */
5849 {
5850    RgSchCmnDlCell     *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
5851    RgSchDlTbAllocInfo *tbAllocInfo = &rbAllocInfo->tbInfo[tbAllocIdx];
5852    RgSchDlHqTbCb      *tbInfo = tbAllocInfo->tbCb;
5853    RgSchDlHqProcCb    *hqP = tbInfo->hqP;
5854
5855    TRC2(rgSCHCmnFillHqPTb);
5856
5857    /*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
5858     * Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
5859     */
5860    if ( tbAllocInfo->isDisabled)
5861    {
5862
5863       tbInfo->dlGrnt.iMcs = 0;
5864       tbInfo->dlGrnt.rv   = 1;
5865    }
5866    /* Fill for TB retransmission */
5867    else if (tbInfo->txCntr > 0)
5868    {
5869
5870       tbInfo->timingInfo = cmnCellDl->time;
5871       /* Fix */
5872       if ((tbInfo->isAckNackDtx == TFU_HQFDB_DTX)) 
5873       {
5874          tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;         
5875          rgHqRvRetxCnt[tbInfo->dlGrnt.rv][tbInfo->tbIdx]++;
5876       }
5877       else
5878       {
5879          tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[++(tbInfo->ccchSchdInfo.rvIdx) & 0x03];
5880       }
5881
5882       /* fill the scheduler information of hqProc */
5883       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5884       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx,hqP->tbInfo,tbInfo->tbIdx );
5885       rgSCHDhmHqTbRetx(hqP->hqE, tbInfo->timingInfo, hqP, tbInfo->tbIdx);
5886    }
5887    /* Fill for TB transmission */
5888    else
5889    {
5890       /* Fill the HqProc */
5891       tbInfo->dlGrnt.iMcs = tbAllocInfo->imcs;
5892       tbInfo->tbSz = tbAllocInfo->bytesAlloc;
5893       tbInfo->timingInfo = cmnCellDl->time;
5894
5895       tbInfo->dlGrnt.rv = rgSchCmnDlRvTbl[0];
5896       /* fill the scheduler information of hqProc */
5897       tbInfo->ccchSchdInfo.rvIdx = 0;
5898       tbInfo->ccchSchdInfo.totBytes = tbAllocInfo->bytesAlloc;
5899       /* DwPts Scheduling Changes Start */
5900       /* DwPts Scheduling Changes End */ 
5901       cell->measurements.dlBytesCnt += tbAllocInfo->bytesAlloc;
5902    }
5903
5904    /*ccpu00120365:-ADD-only add to subFrm list if tb is not disabled */
5905    if ( tbAllocInfo->isDisabled == FALSE )
5906    {
5907       /* Set the number of transmitting SM layers for this TB */
5908       tbInfo->numLyrs = tbAllocInfo->noLyr;
5909       /* Set the TB state as WAITING to indicate TB has been
5910        * considered for transmission */
5911       tbInfo->state  = HQ_TB_WAITING;
5912       hqP->subFrm = rbAllocInfo->dlSf;
5913       tbInfo->hqP->pdcch  = pdcch;
5914       //tbInfo->dlGrnt.numRb = rbAllocInfo->rbsAlloc;
5915       rgSCHUtlDlHqPTbAddToTx(hqP->subFrm, hqP, tbInfo->tbIdx);
5916    }
5917    RETVOID;
5918 }
5919
5920 /**
5921  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
5922  *
5923  * @details
5924  *
5925  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
5926  *     Purpose:  This function fills in the PDCCH information
5927  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
5928  *               for dedicated service scheduling. It also
5929  *               obtains TPC to be filled in from the power module.
5930  *               Assign the PDCCH to HQProc.
5931  *
5932  *     Invoked by: Downlink Scheduler
5933  *
5934  *  @param[in]  RgSchCellCb*      cell
5935  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
5936  *  @param[in]  RgDlHqProc*       hqP
5937  *  @param[out]  RgSchPdcch        *pdcch
5938  *  @param[in]   U8               tpc
5939  *  @return  Void
5940  *
5941  **/
5942 #ifdef ANSI
5943 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
5944 (
5945 RgSchCellCb                *cell,
5946 RgSchDlRbAlloc             *rbAllocInfo,
5947 RgSchDlHqProcCb            *hqP,
5948 RgSchPdcch                 *pdcch,
5949 U8                         tpc
5950 )
5951 #else
5952 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
5953 RgSchCellCb                *cell;
5954 RgSchDlRbAlloc             *rbAllocInfo;
5955 RgSchDlHqProcCb            *hqP;
5956 RgSchPdcch                 *pdcch;
5957 U8                         tpc;
5958 #endif
5959 {
5960
5961    TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
5962
5963    rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);   
5964    //Currently hardcoding values here.
5965    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
5966    switch(rbAllocInfo->dciFormat)
5967    {
5968       case TFU_DCI_FORMAT_B1:
5969          {
5970             pdcch->dci.u.formatB1Info.formatType = 0;
5971             pdcch->dci.u.formatB1Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
5972             pdcch->dci.u.formatB1Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
5973             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
5974             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
5975             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
5976             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
5977             pdcch->dci.u.formatB1Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
5978             pdcch->dci.u.formatB1Info.CSI_BSI_BRI_Req = 0;
5979             pdcch->dci.u.formatB1Info.CSIRS_BRRS_TxTiming = 0;
5980             pdcch->dci.u.formatB1Info.CSIRS_BRRS_SymbIdx = 0;
5981             pdcch->dci.u.formatB1Info.CSIRS_BRRS_ProcInd = 0;
5982             pdcch->dci.u.formatB1Info.xPUCCH_TxTiming = 0;
5983             //TODO_SID: Need to update
5984             pdcch->dci.u.formatB1Info.freqResIdx_xPUCCH = 0;
5985             pdcch->dci.u.formatB1Info.beamSwitch  = 0;
5986             pdcch->dci.u.formatB1Info.SRS_Config = 0;
5987             pdcch->dci.u.formatB1Info.SRS_Symbol = 0;
5988             //TODO_SID: Need to check.Currently setting 0(1 layer, ports(8) w/o OCC).
5989             pdcch->dci.u.formatB1Info.AntPorts_numLayers = 0;
5990             pdcch->dci.u.formatB1Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
5991             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
5992             pdcch->dci.u.formatB1Info.tpcCmd = 1; //tpc;
5993             pdcch->dci.u.formatB1Info.DL_PCRS = 0;
5994             break;
5995          }
5996       case TFU_DCI_FORMAT_B2:
5997          {
5998             pdcch->dci.u.formatB2Info.formatType = 1;
5999             pdcch->dci.u.formatB2Info.xPDSCHRange = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange;
6000             pdcch->dci.u.formatB2Info.RBAssign = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign;
6001             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.hqProcId = hqP->procId;
6002             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.mcs = rbAllocInfo->tbInfo[0].imcs;
6003             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6004             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.RV = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6005             pdcch->dci.u.formatB2Info.u.rbAssignB1Val324.bmiHqAckNack = 0;
6006             pdcch->dci.u.formatB2Info.CSI_BSI_BRI_Req = 0;
6007             pdcch->dci.u.formatB2Info.CSIRS_BRRS_TxTiming = 0;
6008             pdcch->dci.u.formatB2Info.CSIRS_BRRS_SymbIdx = 0;
6009             pdcch->dci.u.formatB2Info.CSIRS_BRRS_ProcInd = 0;
6010             pdcch->dci.u.formatB2Info.xPUCCH_TxTiming = 0;
6011             //TODO_SID: Need to update
6012             pdcch->dci.u.formatB2Info.freqResIdx_xPUCCH = 0;
6013             pdcch->dci.u.formatB2Info.beamSwitch  = 0;
6014             pdcch->dci.u.formatB2Info.SRS_Config = 0;
6015             pdcch->dci.u.formatB2Info.SRS_Symbol = 0;
6016             //TODO_SID: Need to check.Currently setting 4(2 layer, ports(8,9) w/o OCC).
6017             pdcch->dci.u.formatB2Info.AntPorts_numLayers = 4;
6018             pdcch->dci.u.formatB2Info.SCID = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.SCID;
6019             //TODO_SID: Hardcoding TPC command to 1 i.e. No change
6020             pdcch->dci.u.formatB2Info.tpcCmd = 1; //tpc;
6021             pdcch->dci.u.formatB2Info.DL_PCRS = 0;
6022             break;
6023          }
6024          default:
6025             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId," 5GTF_ERROR Allocator's icorrect "
6026                "dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
6027             break;
6028    }
6029    
6030    RETVOID;
6031 }
6032
6033 extern U32 totPcellSCell;
6034 extern U32 addedForScell;
6035 extern U32 addedForScell1;
6036 extern U32 addedForScell2;
6037 /**
6038  * @brief This function fills the PDCCH information from dlProc.
6039  *
6040  * @details
6041  *
6042  *     Function: rgSCHCmnFillHqPPdcch
6043  *     Purpose:  This function fills in the PDCCH information
6044  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6045  *               for dedicated service scheduling. It also
6046  *               obtains TPC to be filled in from the power module.
6047  *               Assign the PDCCH to HQProc.
6048  *
6049  *     Invoked by: Downlink Scheduler
6050  *
6051  *  @param[in]  RgSchCellCb*      cell
6052  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6053  *  @param[in]  RgDlHqProc*       hqP
6054  *  @return  Void
6055  *
6056  **/
6057 #ifdef ANSI
6058 PUBLIC Void rgSCHCmnFillHqPPdcch
6059 (
6060 RgSchCellCb                *cell,
6061 RgSchDlRbAlloc             *rbAllocInfo,
6062 RgSchDlHqProcCb            *hqP
6063 )
6064 #else
6065 PUBLIC Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
6066 RgSchCellCb                *cell;
6067 RgSchDlRbAlloc             *rbAllocInfo;
6068 RgSchDlHqProcCb            *hqP;
6069 #endif
6070 {
6071    RgSchCmnDlCell     *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
6072    RgSchPdcch         *pdcch = rbAllocInfo->pdcch;
6073    U8                 tpc = 1;
6074
6075    TRC2(rgSCHCmnFillHqPPdcch);
6076
6077    if (hqP->hqE->ue)
6078    {
6079 #ifdef LTE_ADV
6080       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6081       {
6082          tpc = hqP->tpc;
6083       }
6084       else
6085 #endif
6086       {
6087          tpc = rgSCHPwrPucchTpcForUe(cell, hqP->hqE->ue);
6088       }
6089       /* Fix: syed moving this to a common function for both scheduled
6090        * and non-scheduled UEs */
6091
6092       pdcch->ue = hqP->hqE->ue;
6093       if (hqP->hqE->ue->csgMmbrSta == FALSE)
6094       {
6095          cmnCell->ncsgPrbCnt += rbAllocInfo->rbsAlloc;
6096       }
6097       cmnCell->totPrbCnt += rbAllocInfo->rbsAlloc;
6098 #ifdef TENB_STATS
6099       {
6100          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlPrbUsg += 
6101             rbAllocInfo->rbsAlloc;
6102          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw0iTbs += 
6103             rbAllocInfo->tbInfo[0].iTbs;
6104          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw0iTbs ++; 
6105          hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6106             (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6107
6108 #ifdef LTE_ADV
6109       totPcellSCell += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6110       if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6111       {
6112          addedForScell +=  (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6113          addedForScell1 += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
6114 /*
6115          printf (" Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
6116          hqP->procId,
6117          hqP->hqE->cell->cellId,
6118          addedForScell,
6119          addedForScell1,
6120          cell->crntTime.sfn,
6121          cell->crntTime.slot);
6122          */
6123       }
6124 #endif
6125          hqP->hqE->cell->tenbStats->sch.dlPrbUsage[0] += 
6126             rbAllocInfo->rbsAlloc;
6127          hqP->hqE->cell->tenbStats->sch.dlSumCw0iTbs += 
6128             rbAllocInfo->tbInfo[0].iTbs;
6129          hqP->hqE->cell->tenbStats->sch.dlNumCw0iTbs ++; 
6130          hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6131             (rbAllocInfo->tbInfo[0].bytesAlloc << 3); 
6132          if (rbAllocInfo->tbInfo[1].schdlngForTb)
6133          {
6134             hqP->hqE->cell->tenbStats->sch.dlSumCw1iTbs += 
6135                rbAllocInfo->tbInfo[1].iTbs;
6136             hqP->hqE->cell->tenbStats->sch.dlNumCw1iTbs ++; 
6137             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlSumCw1iTbs += 
6138                rbAllocInfo->tbInfo[1].iTbs;
6139             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlNumCw1iTbs ++; 
6140             hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt +=
6141                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6142
6143
6144 #ifdef LTE_ADV
6145             if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue, cell))
6146             {
6147                addedForScell +=  (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6148                addedForScell2 += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6149 /*
6150          printf (" Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
6151          hqP->procId,
6152          hqP->hqE->cell->cellId,
6153          addedForScell,
6154          addedForScell2);
6155          */
6156             }
6157             totPcellSCell += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6158 #endif
6159
6160
6161             hqP->hqE->cell->tenbStats->sch.dlTtlTpt +=
6162                (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
6163          }
6164          /*
6165          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 ,
6166          cell->crntTime.sfn,
6167          cell->crntTime.slot);
6168          */
6169       }
6170 #endif
6171    }
6172
6173    pdcch->rnti                       = rbAllocInfo->rnti;
6174    pdcch->dci.dciFormat              = rbAllocInfo->dciFormat;
6175    /* Update subframe and pdcch info in HqTb control block */
6176    switch(rbAllocInfo->dciFormat)
6177    {
6178 #ifdef RG_5GTF  
6179       case TFU_DCI_FORMAT_B1:
6180       case TFU_DCI_FORMAT_B2:
6181            {
6182         // printf(" RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
6183               rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, \
6184                     pdcch, tpc);
6185               break;
6186            }
6187 #endif
6188       default:
6189          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6190             "Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
6191          break;
6192    }
6193    RETVOID;
6194 }
6195 #ifdef UNUSED_FUNC
6196 /**
6197  * @brief This function fills the PDCCH DCI format 1 information from dlProc.
6198  *
6199  * @details
6200  *
6201  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1
6202  *     Purpose:  This function fills in the PDCCH information
6203  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6204  *               for dedicated service scheduling. It also
6205  *               obtains TPC to be filled in from the power module.
6206  *               Assign the PDCCH to HQProc.
6207  *
6208  *     Invoked by: Downlink Scheduler
6209  *
6210  *  @param[in]  RgSchCellCb*      cell
6211  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6212  *  @param[in]  RgDlHqProc*       hqP
6213  *  @param[out]  RgSchPdcch        *pdcch
6214  *  @param[in]   U8               tpc
6215  *  @return  Void
6216  *
6217  **/
6218
6219 #ifdef ANSI
6220 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1
6221 (
6222 RgSchCellCb                *cell,
6223 RgSchDlRbAlloc             *rbAllocInfo,
6224 RgSchDlHqProcCb            *hqP,
6225 RgSchPdcch                 *pdcch,
6226 U8                         tpc
6227 )
6228 #else
6229 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
6230 RgSchCellCb                *cell;
6231 RgSchDlRbAlloc             *rbAllocInfo;
6232 RgSchDlHqProcCb            *hqP;
6233 RgSchPdcch                 *pdcch;
6234 U8                         tpc;
6235 #endif
6236 {
6237
6238 #ifdef LTE_TDD
6239    RgSchTddANInfo     *anInfo;
6240 #endif
6241
6242 #ifdef LTEMAC_SPS
6243 /* For activation or reactivation,
6244  * Harq ProcId should be 0 */
6245    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6246 #endif
6247
6248     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
6249
6250     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6251     pdcch->dci.u.format1Info.tpcCmd = tpc;
6252      /* Avoiding this check,as we dont support Type1 RA */
6253 #ifdef RG_UNUSED
6254     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6255     {
6256 #endif
6257        pdcch->dci.u.format1Info.allocInfo.isAllocType0 = TRUE;
6258        pdcch->dci.u.format1Info.allocInfo.resAllocMap[0] =
6259          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6260                & 0xff);
6261        pdcch->dci.u.format1Info.allocInfo.resAllocMap[1] =
6262          ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6263                & 0x00ff);
6264        pdcch->dci.u.format1Info.allocInfo.resAllocMap[2] =
6265            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6266                & 0x0000ff);
6267        pdcch->dci.u.format1Info.allocInfo.resAllocMap[3] =
6268            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6269 #ifdef RG_UNUSED
6270     }
6271 #endif
6272 #ifdef LTEMAC_SPS
6273     if ((!(hqP->tbInfo[0].txCntr)) &&
6274        (cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6275          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6276          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV)))
6277        )
6278     {
6279        pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6280     }
6281     else
6282     {
6283       pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6284     }
6285 #else
6286     pdcch->dci.u.format1Info.allocInfo.harqProcId = hqP->procId;
6287 #endif
6288
6289     pdcch->dci.u.format1Info.allocInfo.ndi = 
6290                         rbAllocInfo->tbInfo[0].tbCb->ndi;
6291     pdcch->dci.u.format1Info.allocInfo.mcs = 
6292                         rbAllocInfo->tbInfo[0].imcs;
6293     pdcch->dci.u.format1Info.allocInfo.rv = 
6294                         rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6295 #ifdef LTE_TDD
6296        if(hqP->hqE->ue != NULLP)
6297        {
6298 #ifdef LTE_ADV
6299            U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6300                                         hqP->hqE->cell->cellId,
6301                                         hqP->hqE->ue);
6302
6303            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6304                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6305 #else
6306            anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6307                             &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6308 #endif
6309 #ifdef TFU_TDD
6310           if(anInfo)
6311           {
6312              pdcch->dci.u.format1Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6313           }
6314           else
6315           {
6316                /* Fixing DAI value - ccpu00109162 */
6317              pdcch->dci.u.format1Info.dai = RG_SCH_MAX_DAI_IDX;
6318           }
6319 #endif
6320        }
6321        else
6322        {
6323             /* always 0 for RACH */
6324            pdcch->dci.u.format1Info.allocInfo.harqProcId = 0;
6325 #ifdef TFU_TDD
6326             /* Fixing DAI value - ccpu00109162 */
6327            pdcch->dci.u.format1Info.dai = 1;
6328 #endif
6329        }
6330 #endif
6331  
6332
6333        RETVOID;
6334 }
6335 /**
6336  * @brief This function fills the PDCCH DCI format 1A information from dlProc.
6337  *
6338  * @details
6339  *
6340  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1A
6341  *     Purpose:  This function fills in the PDCCH information
6342  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6343  *               for dedicated service scheduling. It also
6344  *               obtains TPC to be filled in from the power module.
6345  *               Assign the PDCCH to HQProc.
6346  *
6347  *     Invoked by: Downlink Scheduler
6348  *
6349  *  @param[in]  RgSchCellCb*      cell
6350  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6351  *  @param[in]  RgDlHqProc*       hqP
6352  *  @param[out]  RgSchPdcch        *pdcch
6353  *  @param[in]   U8               tpc
6354  *  @return  Void
6355  *
6356  **/
6357 #ifdef ANSI
6358 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A
6359 (
6360 RgSchCellCb                *cell,
6361 RgSchDlRbAlloc             *rbAllocInfo,
6362 RgSchDlHqProcCb            *hqP,
6363 RgSchPdcch                 *pdcch,
6364 U8                         tpc
6365 )
6366 #else
6367 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
6368 RgSchCellCb                *cell;
6369 RgSchDlRbAlloc             *rbAllocInfo;
6370 RgSchDlHqProcCb            *hqP;
6371 RgSchPdcch                 *pdcch;
6372 U8                         tpc;
6373 #endif
6374 {
6375
6376 #ifdef LTE_TDD
6377    RgSchTddANInfo     *anInfo;
6378 #endif
6379
6380 #ifdef LTEMAC_SPS
6381    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6382 #endif
6383
6384     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
6385
6386     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6387     pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
6388     pdcch->dci.u.format1aInfo.t.pdschInfo.tpcCmd  = tpc;
6389     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.mcs     = \
6390       rbAllocInfo->tbInfo[0].imcs;
6391     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres = TRUE;
6392 #ifdef LTEMAC_SPS
6393     if ((!(hqP->tbInfo[0].txCntr)) &&
6394        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6395          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6396          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6397        ))
6398     {
6399        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val = 0;
6400     }
6401     else
6402     {
6403       pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val
6404                                                 = hqP->procId;
6405     }
6406 #else
6407     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.val =
6408                                               hqP->procId;
6409 #endif
6410     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.ndi     = \
6411        rbAllocInfo->tbInfo[0].tbCb->ndi;
6412     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv      = \
6413        rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6414          /* As of now, we do not support Distributed allocations */
6415     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.isLocal = TRUE;
6416     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.nGap2.pres = NOTPRSNT;
6417     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.type =
6418             TFU_ALLOC_TYPE_RIV;
6419     pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.alloc.u.riv =
6420     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6421                   rbAllocInfo->allocInfo.raType2.rbStart,
6422                   rbAllocInfo->allocInfo.raType2.numRb);
6423 #ifdef LTE_TDD
6424     if(hqP->hqE->ue != NULLP)
6425     {
6426 #ifdef LTE_ADV
6427        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6428                                         hqP->hqE->cell->cellId,
6429                                         hqP->hqE->ue);
6430        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6431                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6432 #else
6433        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6434                               &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6435 #endif
6436 #ifdef TFU_TDD
6437        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6438        if(anInfo)
6439        {
6440           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 
6441                               RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6442        }
6443        else
6444        {
6445           /* Fixing DAI value - ccpu00109162 */
6446           pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = RG_SCH_MAX_DAI_IDX;
6447           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6448                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6449                     rbAllocInfo->rnti);
6450        }
6451 #endif
6452     }
6453     else
6454     {
6455             /* always 0 for RACH */
6456        pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.harqProcId.pres
6457                                                                      = FALSE;
6458 #ifdef TFU_TDD
6459        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.pres = TRUE;
6460             /* Fixing DAI value - ccpu00109162 */
6461        pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = 1;
6462 #endif
6463     }
6464 #endif
6465  
6466     RETVOID;
6467 }       
6468 /**
6469  * @brief This function fills the PDCCH DCI format 1B information from dlProc.
6470  *
6471  * @details
6472  *
6473  *     Function: rgSCHCmnFillHqPPdcchDciFrmt1B
6474  *     Purpose:  This function fills in the PDCCH information
6475  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6476  *               for dedicated service scheduling. It also
6477  *               obtains TPC to be filled in from the power module.
6478  *               Assign the PDCCH to HQProc.
6479  *
6480  *     Invoked by: Downlink Scheduler
6481  *
6482  *  @param[in]  RgSchCellCb*      cell
6483  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6484  *  @param[in]  RgDlHqProc*       hqP
6485  *  @param[out]  RgSchPdcch        *pdcch
6486  *  @param[in]   U8               tpc
6487  *  @return  Void
6488  *
6489  **/
6490 #ifdef ANSI
6491 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B
6492 (
6493 RgSchCellCb                *cell,
6494 RgSchDlRbAlloc             *rbAllocInfo,
6495 RgSchDlHqProcCb            *hqP,
6496 RgSchPdcch                 *pdcch,
6497 U8                         tpc
6498 )
6499 #else
6500 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
6501 RgSchCellCb                *cell;
6502 RgSchDlRbAlloc             *rbAllocInfo;
6503 RgSchDlHqProcCb            *hqP;
6504 RgSchPdcch                 *pdcch;
6505 U8                         tpc;
6506 #endif
6507 {
6508
6509 #ifdef LTE_TDD
6510    RgSchTddANInfo     *anInfo;
6511 #endif
6512
6513 #ifdef LTEMAC_SPS
6514    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6515 #endif
6516
6517     TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
6518
6519     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6520     pdcch->dci.u.format1bInfo.tpcCmd  = tpc;
6521     pdcch->dci.u.format1bInfo.allocInfo.mcs     = \
6522            rbAllocInfo->tbInfo[0].imcs;
6523 #ifdef LTEMAC_SPS
6524     if ((!(hqP->tbInfo[0].txCntr)) &&
6525        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6526          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6527          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6528        ))
6529     {
6530        pdcch->dci.u.format1bInfo.allocInfo.harqProcId = 0;
6531     }
6532     else
6533     {
6534       pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6535     }
6536 #else
6537     pdcch->dci.u.format1bInfo.allocInfo.harqProcId = hqP->procId;
6538 #endif
6539     pdcch->dci.u.format1bInfo.allocInfo.ndi     = \
6540           rbAllocInfo->tbInfo[0].tbCb->ndi;
6541     pdcch->dci.u.format1bInfo.allocInfo.rv      = \
6542            rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6543          /* As of now, we do not support Distributed allocations */
6544     pdcch->dci.u.format1bInfo.allocInfo.isLocal = TRUE;
6545     pdcch->dci.u.format1bInfo.allocInfo.nGap2.pres = NOTPRSNT;
6546     pdcch->dci.u.format1bInfo.allocInfo.alloc.type =
6547             TFU_ALLOC_TYPE_RIV;
6548     pdcch->dci.u.format1bInfo.allocInfo.alloc.u.riv =
6549     rgSCHCmnCalcRiv (cell->bwCfg.dlTotalBw,
6550                   rbAllocInfo->allocInfo.raType2.rbStart,
6551                   rbAllocInfo->allocInfo.raType2.numRb);
6552          /* Fill precoding Info */
6553     pdcch->dci.u.format1bInfo.allocInfo.pmiCfm = \
6554                rbAllocInfo->mimoAllocInfo.precIdxInfo >> 4;
6555     pdcch->dci.u.format1bInfo.allocInfo.tPmi   = \
6556                rbAllocInfo->mimoAllocInfo.precIdxInfo & 0x0F;
6557 #ifdef LTE_TDD
6558     if(hqP->hqE->ue != NULLP)
6559     {
6560 #ifdef LTE_ADV
6561        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6562                                         hqP->hqE->cell->cellId,
6563                                         hqP->hqE->ue);
6564        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6565              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6566 #else
6567        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6568              &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6569 #endif
6570 #ifdef TFU_TDD
6571        if(anInfo)
6572        {
6573           pdcch->dci.u.format1bInfo.dai = 
6574                          RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6575        }
6576        else
6577        {
6578           pdcch->dci.u.format1bInfo.dai = RG_SCH_MAX_DAI_IDX;
6579           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6580                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6581                    rbAllocInfo->rnti);
6582        }
6583 #endif
6584     }
6585 #endif
6586        
6587     RETVOID;
6588
6589 }
6590 /**
6591  * @brief This function fills the PDCCH DCI format 2 information from dlProc.
6592  *
6593  * @details
6594  *
6595  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2
6596  *     Purpose:  This function fills in the PDCCH information
6597  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6598  *               for dedicated service scheduling. It also
6599  *               obtains TPC to be filled in from the power module.
6600  *               Assign the PDCCH to HQProc.
6601  *
6602  *     Invoked by: Downlink Scheduler
6603  *
6604  *  @param[in]  RgSchCellCb*      cell
6605  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6606  *  @param[in]  RgDlHqProc*       hqP
6607  *  @param[out]  RgSchPdcch        *pdcch
6608  *  @param[in]   U8               tpc
6609  *  @return  Void
6610  *
6611  **/
6612 #ifdef ANSI
6613 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2
6614 (
6615 RgSchCellCb                *cell,
6616 RgSchDlRbAlloc             *rbAllocInfo,
6617 RgSchDlHqProcCb            *hqP,
6618 RgSchPdcch                 *pdcch,
6619 U8                         tpc
6620 )
6621 #else
6622 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
6623 RgSchCellCb                *cell;
6624 RgSchDlRbAlloc             *rbAllocInfo;
6625 RgSchDlHqProcCb            *hqP;
6626 RgSchPdcch                 *pdcch;
6627 U8                         tpc;
6628 #endif
6629 {
6630
6631 #ifdef LTE_TDD
6632    RgSchTddANInfo     *anInfo;
6633 #endif
6634
6635 #ifdef LTEMAC_SPS
6636 /* ccpu00119023-ADD-For activation or reactivation,
6637  * Harq ProcId should be 0 */
6638    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6639 #endif
6640
6641     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
6642
6643     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6644     /*ccpu00120365:-ADD-call also if tb is disabled */
6645     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6646         rbAllocInfo->tbInfo[1].isDisabled)
6647     {
6648         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6649     }
6650     pdcch->dci.u.format2Info.tpcCmd = tpc;
6651          /* Avoiding this check,as we dont support Type1 RA */
6652 #ifdef RG_UNUSED
6653     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6654     {
6655 #endif
6656         pdcch->dci.u.format2Info.allocInfo.isAllocType0 = TRUE;
6657         pdcch->dci.u.format2Info.allocInfo.resAllocMap[0] =
6658           ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6659                & 0xff);
6660         pdcch->dci.u.format2Info.allocInfo.resAllocMap[1] =
6661            ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6662                & 0x00ff);
6663         pdcch->dci.u.format2Info.allocInfo.resAllocMap[2] =
6664                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6665                 & 0x0000ff);
6666         pdcch->dci.u.format2Info.allocInfo.resAllocMap[3] =
6667                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6668 #ifdef RG_UNUSED
6669     }
6670 #endif
6671 #ifdef LTEMAC_SPS
6672     if ((!(hqP->tbInfo[0].txCntr)) &&
6673        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6674          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6675          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6676        ))
6677     {
6678        pdcch->dci.u.format2Info.allocInfo.harqProcId = 0;
6679     }
6680     else
6681     {
6682       pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6683     }
6684 #else
6685      pdcch->dci.u.format2Info.allocInfo.harqProcId = hqP->procId;
6686 #endif
6687          /* Initialize the TB info for both the TBs */
6688      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].mcs = 0;
6689      pdcch->dci.u.format2Info.allocInfo.tbInfo[0].rv  = 1;
6690      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].mcs = 0;
6691      pdcch->dci.u.format2Info.allocInfo.tbInfo[1].rv  = 1;
6692          /* Fill tbInfo for scheduled TBs */
6693      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6694         tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6695      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6696         tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6697      pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6698             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6699           /* If we reach this function. It is safely assumed that
6700            *  rbAllocInfo->tbInfo[0] always has non default valid values.
6701            *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6702      if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6703      {
6704             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6705                 tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6706             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6707                 tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6708             pdcch->dci.u.format2Info.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6709                 tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6710      }
6711      pdcch->dci.u.format2Info.allocInfo.transSwap =
6712              rbAllocInfo->mimoAllocInfo.swpFlg;
6713      pdcch->dci.u.format2Info.allocInfo.precoding =
6714              rbAllocInfo->mimoAllocInfo.precIdxInfo;
6715 #ifdef LTE_TDD
6716      if(hqP->hqE->ue != NULLP)
6717      {
6718
6719 #ifdef LTE_ADV
6720         U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6721                                         hqP->hqE->cell->cellId,
6722                                         hqP->hqE->ue);
6723         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6724                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6725 #else
6726         anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6727                            &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6728 #endif
6729 #ifdef TFU_TDD
6730         if(anInfo)
6731         {
6732            pdcch->dci.u.format2Info.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6733         }
6734         else
6735         {
6736            pdcch->dci.u.format2Info.dai = RG_SCH_MAX_DAI_IDX;
6737            RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6738                     "PDCCH is been scheduled without updating anInfo RNTI:%d",
6739                     rbAllocInfo->rnti);
6740         }
6741 #endif
6742      }
6743 #endif
6744
6745      RETVOID;
6746 }
6747 /**
6748  * @brief This function fills the PDCCH DCI format 2A information from dlProc.
6749  *
6750  * @details
6751  *
6752  *     Function: rgSCHCmnFillHqPPdcchDciFrmt2A
6753  *     Purpose:  This function fills in the PDCCH information
6754  *               obtained from the RgSchDlHqProcCb and RgSchDlRbAlloc
6755  *               for dedicated service scheduling. It also
6756  *               obtains TPC to be filled in from the power module.
6757  *               Assign the PDCCH to HQProc.
6758  *
6759  *     Invoked by: Downlink Scheduler
6760  *
6761  *  @param[in]  RgSchCellCb*      cell
6762  *  @param[in]  RgSchDlRbAlloc*   rbAllocInfo
6763  *  @param[in]  RgDlHqProc*       hqP
6764  *  @param[out]  RgSchPdcch        *pdcch
6765  *  @param[in]   U8               tpc
6766  *  @return  Void
6767  *
6768  **/
6769 #ifdef ANSI
6770 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A
6771 (
6772 RgSchCellCb                *cell,
6773 RgSchDlRbAlloc             *rbAllocInfo,
6774 RgSchDlHqProcCb            *hqP,
6775 RgSchPdcch                 *pdcch,
6776 U8                         tpc
6777 )
6778 #else
6779 PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
6780 RgSchCellCb                *cell;
6781 RgSchDlRbAlloc             *rbAllocInfo;
6782 RgSchDlHqProcCb            *hqP;
6783 RgSchPdcch                 *pdcch;
6784 U8                         tpc;
6785 #endif
6786 {
6787 #ifdef LTE_TDD
6788    RgSchTddANInfo     *anInfo;
6789 #endif
6790
6791 #ifdef LTEMAC_SPS
6792    RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
6793 #endif
6794
6795     TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
6796
6797     rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
6798     /*ccpu00120365:-ADD-call also if tb is disabled */
6799     if (rbAllocInfo->tbInfo[1].schdlngForTb ||
6800           rbAllocInfo->tbInfo[1].isDisabled)
6801     {
6802
6803         rgSCHCmnFillHqPTb(cell, rbAllocInfo, 1, pdcch);
6804     }
6805
6806     pdcch->dci.u.format2AInfo.tpcCmd = tpc;
6807          /* Avoiding this check,as we dont support Type1 RA */
6808 #ifdef RG_UNUSED
6809     if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
6810     {
6811 #endif
6812         pdcch->dci.u.format2AInfo.allocInfo.isAllocType0 = TRUE;
6813         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[0] =
6814               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 24)
6815                & 0xff);
6816         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[1] =
6817               ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 16)
6818                & 0x00ff);
6819         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[2] =
6820                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask >> 8)
6821                 & 0x0000ff);
6822         pdcch->dci.u.format2AInfo.allocInfo.resAllocMap[3] =
6823                ((rbAllocInfo->allocInfo.raType0.dlAllocBitMask & 0x000000ff));
6824 #ifdef RG_UNUSED
6825     }
6826 #endif
6827 #ifdef LTEMAC_SPS
6828     if ((!(hqP->tbInfo[0].txCntr)) &&
6829        ( cmnHqDl != (RgSchCmnDlHqProc*)NULLP  &&
6830          ((cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_ACTV) ||
6831          (cmnHqDl->spsAction & RG_SCH_CMN_SPS_DL_REACTV))
6832        ))
6833     {
6834        pdcch->dci.u.format2AInfo.allocInfo.harqProcId = 0;
6835     }
6836     else
6837     {
6838       pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6839     }
6840 #else
6841     pdcch->dci.u.format2AInfo.allocInfo.harqProcId = hqP->procId;
6842 #endif
6843          /* Initialize the TB info for both the TBs */
6844     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].mcs = 0;
6845     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[0].rv  = 1;
6846     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].mcs = 0;
6847     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[1].rv  = 1;
6848          /* Fill tbInfo for scheduled TBs */
6849     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6850             tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[0].tbCb->ndi;
6851     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6852             tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[0].imcs;
6853     pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[0].\
6854             tbCb->tbIdx].rv = rbAllocInfo->tbInfo[0].tbCb->dlGrnt.rv;
6855          /* If we reach this function. It is safely assumed that
6856           *  rbAllocInfo->tbInfo[0] always has non default valid values.
6857           *  rbAllocInfo->tbInfo[1]'s scheduling is optional */
6858
6859     if (rbAllocInfo->tbInfo[1].schdlngForTb == TRUE)
6860     {
6861             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6862                tbCb->tbIdx].ndi = rbAllocInfo->tbInfo[1].tbCb->ndi;
6863             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6864                tbCb->tbIdx].mcs = rbAllocInfo->tbInfo[1].imcs;
6865             pdcch->dci.u.format2AInfo.allocInfo.tbInfo[rbAllocInfo->tbInfo[1].\
6866                tbCb->tbIdx].rv = rbAllocInfo->tbInfo[1].tbCb->dlGrnt.rv;
6867
6868     }
6869     pdcch->dci.u.format2AInfo.allocInfo.transSwap =
6870             rbAllocInfo->mimoAllocInfo.swpFlg;
6871     pdcch->dci.u.format2AInfo.allocInfo.precoding =
6872             rbAllocInfo->mimoAllocInfo.precIdxInfo;
6873 #ifdef LTE_TDD
6874     if(hqP->hqE->ue != NULLP)
6875     {
6876 #ifdef LTE_ADV
6877        U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
6878                                         hqP->hqE->cell->cellId,
6879                                         hqP->hqE->ue);
6880        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6881                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),servCellIdx);
6882 #else
6883        anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
6884                          &(rbAllocInfo->tbInfo[0].tbCb->fdbkTime),0);
6885 #endif
6886 #ifdef TFU_TDD
6887        if(anInfo)
6888        {
6889           pdcch->dci.u.format2AInfo.dai = RG_SCH_GET_DAI_VALUE(anInfo->dlDai);
6890        }
6891        else
6892        {
6893           pdcch->dci.u.format2AInfo.dai = RG_SCH_MAX_DAI_IDX;
6894           RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
6895                    "PDCCH is been scheduled without updating anInfo RNTI:%d",
6896                    rbAllocInfo->rnti);
6897        }
6898 #endif
6899      }
6900 #endif
6901
6902
6903     RETVOID;
6904 }
6905 #endif
6906 /**
6907  * @brief init of Sch vars.
6908  *
6909  * @details
6910  *
6911  *     Function: rgSCHCmnInitVars
6912        Purpose:  Initialization of various UL subframe indices
6913  *
6914  *  @param[in]  RgSchCellCb *cell
6915  *  @return  Void
6916  *
6917  **/
6918 #ifdef ANSI
6919 PRIVATE Void rgSCHCmnInitVars
6920 (
6921 RgSchCellCb *cell
6922 )
6923 #else
6924 PRIVATE Void rgSCHCmnInitVars(cell)
6925 RgSchCellCb *cell;
6926 #endif
6927 {
6928    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6929
6930    TRC2(rgSCHCmnInitVars);
6931
6932    cellUl->idx         = RGSCH_INVALID_INFO;
6933    cellUl->schdIdx     = RGSCH_INVALID_INFO;
6934    cellUl->schdHqProcIdx = RGSCH_INVALID_INFO;
6935    cellUl->msg3SchdIdx = RGSCH_INVALID_INFO;
6936 #ifdef EMTC_ENBLE
6937    cellUl->emtcMsg3SchdIdx = RGSCH_INVALID_INFO;
6938 #endif
6939    cellUl->msg3SchdHqProcIdx = RGSCH_INVALID_INFO;
6940    cellUl->rcpReqIdx   = RGSCH_INVALID_INFO;
6941    cellUl->hqFdbkIdx[0] = RGSCH_INVALID_INFO;
6942    cellUl->hqFdbkIdx[1] = RGSCH_INVALID_INFO;
6943    cellUl->reTxIdx[0]   = RGSCH_INVALID_INFO;
6944    cellUl->reTxIdx[1]   = RGSCH_INVALID_INFO;
6945   /* Stack Crash problem for TRACE5 Changes. Added the return below */
6946   RETVOID;
6947
6948 }
6949
6950 #ifndef LTE_TDD
6951 /**
6952  * @brief Updation of Sch vars per TTI.
6953  *
6954  * @details
6955  *
6956  *     Function: rgSCHCmnUpdVars
6957  *     Purpose:  Updation of Sch vars per TTI.
6958  *
6959  *  @param[in]  RgSchCellCb *cell
6960  *  @return  Void
6961  *
6962  **/
6963 #ifdef ANSI
6964 PUBLIC Void rgSCHCmnUpdVars
6965 (
6966 RgSchCellCb *cell
6967 )
6968 #else
6969 PUBLIC Void rgSCHCmnUpdVars(cell)
6970 RgSchCellCb *cell;
6971 #endif
6972 {
6973    CmLteTimingInfo   timeInfo;
6974    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
6975    U16 idx;
6976
6977    TRC2(rgSCHCmnUpdVars);
6978
6979    idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
6980    cellUl->idx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
6981 #ifdef UL_ADPT_DBG     
6982    printf("idx %d cellUl->idx  %d RGSCH_NUM_SUB_FRAMES_5G %d  time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
6983 #endif    
6984    /* Need to scheduler for after SCHED_DELTA */
6985    /* UL allocation has been advanced by 1 subframe
6986     * so that we do not wrap around and send feedback
6987     * before the data is even received by the PHY */
6988    /* Introduced timing delta for UL control */
6989    idx = (cellUl->idx + TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA);
6990    cellUl->schdIdx     = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
6991
6992    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
6993             TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA)
6994    cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
6995
6996    /* ccpu00127193 filling schdTime for logging and enhancement purpose*/
6997    cellUl->schdTime = timeInfo;
6998
6999    /* msg3 scheduling two subframes after general scheduling */
7000    idx = (cellUl->idx + RG_SCH_CMN_DL_DELTA + RGSCH_RARSP_MSG3_DELTA);
7001    cellUl->msg3SchdIdx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7002
7003    RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,
7004             RG_SCH_CMN_DL_DELTA+ RGSCH_RARSP_MSG3_DELTA)
7005    cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
7006
7007    idx = (cellUl->idx + TFU_RECPREQ_DLDELTA);
7008
7009    cellUl->rcpReqIdx   = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
7010
7011    /* Downlink harq feedback is sometime after data reception / harq failure */
7012    /* Since feedback happens prior to scheduling being called, we add 1 to   */
7013    /* take care of getting the correct subframe for feedback                 */
7014    idx = (cellUl->idx - TFU_CRCIND_ULDELTA + RG_SCH_CMN_UL_NUM_SF);
7015 #ifdef UL_ADPT_DBG     
7016    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);
7017 #endif
7018    cellUl->hqFdbkIdx[0]   = (idx % (RG_SCH_CMN_UL_NUM_SF));
7019
7020    idx = ((cellUl->schdIdx) % (RG_SCH_CMN_UL_NUM_SF));
7021
7022    cellUl->reTxIdx[0] = (U8) idx;
7023 #ifdef UL_ADPT_DBG     
7024    printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
7025 #endif
7026    /* RACHO: update cmn sched specific RACH variables,
7027     * mainly the prachMaskIndex */
7028    rgSCHCmnUpdRachParam(cell);
7029
7030    RETVOID;
7031 }
7032 #endif
7033
7034 #ifdef LTE_TDD
7035
7036 /**
7037  * @brief To get uplink subframe index associated with current PHICH
7038  *        transmission.
7039  *
7040  * @details
7041  *
7042  *     Function: rgSCHCmnGetPhichUlSfIdx
7043  *     Purpose:  Gets uplink subframe index associated with current PHICH
7044  *               transmission based on SFN and subframe no
7045  *
7046  *  @param[in]  CmLteTimingInfo  *timeInfo
7047  *  @param[in]  RgSchCellCb              *cell
7048  *  @return U8
7049  *
7050  **/
7051 #ifdef ANSI
7052 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx
7053 (
7054 CmLteTimingInfo *timeInfo,
7055 RgSchCellCb *cell
7056 )
7057 #else
7058 PUBLIC U8  rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
7059 CmLteTimingInfo *timeInfo;
7060 RgSchCellCb        *cell;
7061 #endif
7062 {
7063    RgSchCmnUlCell       *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7064    RgSchDlSf            *dlsf;
7065    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
7066    U8                   idx;
7067    U16                  numUlSf;
7068    U16                  sfn;
7069    U8                   subframe;
7070
7071    TRC2(rgSCHCmnGetPhichUlSfIdx);
7072
7073    dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
7074
7075    if(dlsf->phichOffInfo.sfnOffset == RGSCH_INVALID_INFO)
7076    {
7077       RETVALUE(RGSCH_INVALID_INFO);
7078    }
7079    subframe = dlsf->phichOffInfo.subframe;
7080
7081    sfn = (RGSCH_MAX_SFN + timeInfo->sfn -
7082                    dlsf->phichOffInfo.sfnOffset) % RGSCH_MAX_SFN;
7083
7084    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7085     * wrap case such that idx will be proper*/
7086    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7087    numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
7088    idx = numUlSf % (cellUl->numUlSubfrms);
7089
7090    RETVALUE(idx);
7091 }
7092
7093 /**
7094  * @brief To get uplink subframe index.
7095  *
7096  * @details
7097  *
7098  *
7099  *     Function: rgSCHCmnGetUlSfIdx
7100  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7101  *
7102  *  @param[in]  CmLteTimingInfo  *timeInfo
7103  *  @param[in]  U8               ulDlCfgIdx
7104  *  @return U8
7105  *
7106  **/
7107 #ifdef ANSI
7108 PUBLIC U8  rgSCHCmnGetUlSfIdx
7109 (
7110 CmLteTimingInfo *timeInfo,
7111 RgSchCellCb *cell
7112 )
7113 #else
7114 PUBLIC U8  rgSCHCmnGetUlSfIdx(timeInfo, cell)
7115 CmLteTimingInfo *timeInfo;
7116 RgSchCellCb *cell;
7117 #endif
7118 {
7119    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
7120    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
7121    U8                idx = 0;
7122    U16               numUlSf;
7123
7124    TRC2(rgSCHCmnGetUlSfIdx);
7125
7126    /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
7127     * wrap case such that idx will be proper*/
7128    numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7129    numUlSf = ((numUlSf * timeInfo->sfn) + \
7130          rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->subframe]) - 1;
7131    idx = numUlSf % (cellUl->numUlSubfrms);
7132
7133    RETVALUE(idx);
7134 }
7135
7136 #endif
7137
7138 /**
7139  * @brief To get uplink hq index.
7140  *
7141  * @details
7142  *
7143  *
7144  *     Function: rgSCHCmnGetUlHqProcIdx
7145  *     Purpose:  Gets uplink subframe index based on SFN and subframe number.
7146  *
7147  *  @param[in]  CmLteTimingInfo  *timeInfo
7148  *  @param[in]  U8               ulDlCfgIdx
7149  *  @return U8
7150  *
7151  **/
7152 #ifdef ANSI
7153 PUBLIC U8  rgSCHCmnGetUlHqProcIdx
7154 (
7155 CmLteTimingInfo *timeInfo,
7156 RgSchCellCb *cell
7157 )
7158 #else
7159 PUBLIC U8  rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
7160 CmLteTimingInfo *timeInfo;
7161 RgSchCellCb *cell;
7162 #endif
7163 {
7164    U8            procId;
7165    U32           numUlSf;
7166   
7167 #ifndef LTE_TDD
7168    numUlSf  = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->slot);
7169    procId   = numUlSf % RGSCH_NUM_UL_HQ_PROC;
7170 #else
7171    U8            ulDlCfgIdx = cell->ulDlCfgIdx;
7172    /*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
7173    U8            numUlSfInSfn;
7174    S8            sfnCycle = cell->tddHqSfnCycle;
7175    U8            numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
7176
7177    /* TRACE 5 Changes */
7178    TRC2(rgSCHCmnGetUlHqProcIdx);
7179
7180    /* Calculate the number of UL SF in one SFN */
7181    numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
7182                rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
7183
7184    /* Check for the SFN wrap around case */
7185    if(cell->crntTime.sfn == 1023 && timeInfo->sfn == 0)
7186    {
7187       sfnCycle++;
7188    }
7189    else if(cell->crntTime.sfn == 0 && timeInfo->sfn == 1023)
7190    {
7191       /* sfnCycle decremented by 1 */
7192       sfnCycle = (sfnCycle + numUlHarq-1) % numUlHarq;
7193    }
7194    /* Calculate the total number of UL sf */
7195    /*  -1 is done since uplink sf are counted from 0 */
7196    numUlSf = numUlSfInSfn *  (timeInfo->sfn + (sfnCycle*1024)) +
7197                   rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][timeInfo->slot] - 1;
7198
7199    procId = numUlSf % numUlHarq;   
7200 #endif
7201    RETVALUE(procId);
7202 }
7203
7204
7205 /* UL_ALLOC_CHANGES */
7206 /***********************************************************
7207  *
7208  *     Func : rgSCHCmnUlFreeAlloc
7209  *
7210  *     Desc : Free an allocation - invokes UHM and releases
7211  *            alloc for the scheduler
7212  *            Doest need subframe as argument
7213  *
7214  *     Ret  :
7215  *
7216  *     Notes:
7217  *
7218  *     File :
7219  *
7220  **********************************************************/
7221 #ifdef ANSI
7222 PUBLIC Void rgSCHCmnUlFreeAlloc
7223 (
7224 RgSchCellCb     *cell,
7225 RgSchUlAlloc    *alloc
7226 )
7227 #else
7228 PUBLIC Void rgSCHCmnUlFreeAlloc(cell, alloc)
7229 RgSchCellCb     *cell;
7230 RgSchUlAlloc    *alloc;
7231 #endif
7232 {
7233    RgSchUlHqProcCb *hqProc;
7234    TRC2(rgSCHCmnUlFreeAllocation);
7235
7236    if (alloc->forMsg3)
7237    {
7238       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7239       if ((alloc->hqProc->remTx == 0) &&
7240           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7241           (alloc->raCb))
7242       {
7243          RgSchRaCb      *raCb = alloc->raCb;
7244          rgSCHUhmFreeProc(alloc->hqProc, cell);
7245          rgSCHUtlUlAllocRelease(alloc);
7246          rgSCHRamDelRaCb(cell, raCb, TRUE);
7247          RETVOID;
7248       }
7249    }
7250    
7251    hqProc = alloc->hqProc;
7252    rgSCHUtlUlAllocRelease(alloc);
7253    rgSCHUhmFreeProc(hqProc, cell);
7254    RETVOID;
7255 }
7256
7257
7258 /***********************************************************
7259  *
7260  *     Func : rgSCHCmnUlFreeAllocation
7261  *
7262  *     Desc : Free an allocation - invokes UHM and releases
7263  *            alloc for the scheduler
7264  *
7265  *     Ret  :
7266  *
7267  *     Notes:
7268  *
7269  *     File :
7270  *
7271  **********************************************************/
7272 #ifdef ANSI
7273 PUBLIC Void rgSCHCmnUlFreeAllocation
7274 (
7275 RgSchCellCb     *cell,
7276 RgSchUlSf       *sf,
7277 RgSchUlAlloc    *alloc
7278 )
7279 #else
7280 PUBLIC Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
7281 RgSchCellCb     *cell;
7282 RgSchUlSf       *sf;
7283 RgSchUlAlloc    *alloc;
7284 #endif
7285 {
7286    RgSchUlHqProcCb *hqProc;
7287
7288    TRC2(rgSCHCmnUlFreeAllocation);
7289
7290    if (alloc->forMsg3)
7291    {
7292       /* Fix : Release RNTI upon MSG3 max TX failure for non-HO UEs */
7293       if ((alloc->hqProc->remTx == 0) &&
7294           (alloc->hqProc->rcvdCrcInd == FALSE) &&
7295           (alloc->raCb))
7296       {
7297          RgSchRaCb      *raCb = alloc->raCb;
7298          rgSCHUhmFreeProc(alloc->hqProc, cell);
7299          rgSCHUtlUlAllocRls(sf, alloc);
7300          rgSCHRamDelRaCb(cell, raCb, TRUE);
7301          RETVOID;
7302       }
7303    }
7304    
7305    hqProc = alloc->hqProc;
7306    rgSCHUhmFreeProc(hqProc, cell);
7307 #ifdef LTE_L2_MEAS
7308    /* re-setting the PRB count while freeing the allocations */
7309    sf->totPrb = 0;
7310 #endif
7311    rgSCHUtlUlAllocRls(sf, alloc);
7312
7313    RETVOID;
7314 }
7315
7316 /**
7317  * @brief This function implements PDCCH allocation for an UE
7318  *        in the currently running subframe.
7319  *
7320  * @details
7321  *
7322  *     Function: rgSCHCmnPdcchAllocCrntSf
7323  *     Purpose:  This function determines current DL subframe
7324  *               and UE DL CQI to call the actual pdcch allocator
7325  *               function.
7326  *               Note that this function is called only
7327  *               when PDCCH request needs to be made during
7328  *               uplink scheduling.
7329  *
7330  *     Invoked by: Scheduler
7331  *
7332  *  @param[in]  RgSchCellCb  *cell
7333  *  @param[in]  RgSchUeCb    *ue
7334  *  @return  RgSchPdcch *
7335  *         -# NULLP when unsuccessful
7336  **/
7337 #ifdef ANSI
7338 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
7339 (
7340 RgSchCellCb                *cell,
7341 RgSchUeCb                  *ue
7342 )
7343 #else
7344 PUBLIC RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
7345 RgSchCellCb                *cell;
7346 RgSchUeCb                  *ue;
7347 #endif
7348 {
7349    CmLteTimingInfo      frm = cell->crntTime;
7350    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7351    RgSchDlSf            *sf;
7352    RgSchPdcch           *pdcch = NULLP;
7353
7354    TRC2(rgSCHCmnPdcchAllocCrntSf);
7355    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7356    sf = rgSCHUtlSubFrmGet(cell, frm);
7357
7358 #ifdef LTE_ADV
7359    if (ue->allocCmnUlPdcch)
7360    {
7361       pdcch = rgSCHCmnCmnPdcchAlloc(cell, sf);
7362       /* Since CRNTI Scrambled */
7363       if(NULLP != pdcch)
7364       {
7365          pdcch->dciNumOfBits = ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
7366       }
7367    }
7368    else
7369 #endif
7370    {
7371       //pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, y, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_0, FALSE);
7372                 pdcch = rgSCHCmnPdcchAlloc(cell, ue, sf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_A1, FALSE);
7373    }
7374    RETVALUE(pdcch);
7375 }
7376
7377 /***********************************************************
7378  *
7379  *     Func : rgSCHCmnUlAllocFillNdmrs
7380  *
7381  *     Desc : Determines and fills N_dmrs for a UE uplink
7382  *            allocation.
7383  *
7384  *     Ret  :
7385  *
7386  *     Notes: N_dmrs determination is straightforward, so
7387  *            it is configured per subband
7388  *
7389  *     File :
7390  *
7391  **********************************************************/
7392 #ifdef ANSI
7393 PUBLIC Void rgSCHCmnUlAllocFillNdmrs
7394 (
7395 RgSchCmnUlCell *cellUl,
7396 RgSchUlAlloc   *alloc
7397 )
7398 #else
7399 PUBLIC Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
7400 RgSchCmnUlCell *cellUl;
7401 RgSchUlAlloc   *alloc;
7402 #endif
7403 {
7404    TRC2(rgSCHCmnUlAllocFillNdmrs);
7405    alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
7406    RETVOID;
7407 }
7408
7409 /***********************************************************
7410  *
7411  *     Func : rgSCHCmnUlAllocLnkHqProc
7412  *
7413  *     Desc : Links a new allocation for an UE with the
7414  *            appropriate HARQ process of the UE.
7415  *
7416  *     Ret  :
7417  *
7418  *     Notes:
7419  *
7420  *     File :
7421  *
7422  **********************************************************/
7423 #ifdef ANSI
7424 PUBLIC Void rgSCHCmnUlAllocLnkHqProc
7425 (
7426 RgSchUeCb       *ue,
7427 RgSchUlAlloc    *alloc,
7428 RgSchUlHqProcCb *proc,
7429 Bool            isRetx
7430 )
7431 #else
7432 PUBLIC Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
7433 RgSchUeCb       *ue;
7434 RgSchUlAlloc    *alloc;
7435 RgSchUlHqProcCb *proc;
7436 Bool            isRetx;
7437 #endif
7438 {
7439    TRC2(rgSCHCmnUlAllocLnkHqProc);
7440
7441    if(TRUE == isRetx)
7442    {
7443       rgSCHCmnUlAdapRetx(alloc, proc);
7444    }
7445    else
7446    {
7447 #ifdef LTE_L2_MEAS /* L2_COUNTERS */
7448       alloc->ue = ue;
7449 #endif
7450       rgSCHUhmNewTx(proc, (((RgUeUlHqCb*)proc->hqEnt)->maxHqRetx), alloc);
7451    }
7452    RETVOID;
7453 }
7454
7455 /**
7456  * @brief This function releases a PDCCH in the subframe that is
7457  *        currently being allocated for.
7458  *
7459  * @details
7460  *
7461  *     Function: rgSCHCmnPdcchRlsCrntSf
7462  *     Purpose:  This function determines current DL subframe
7463  *               which is considered for PDCCH allocation,
7464  *               and then calls the actual function that
7465  *               releases a PDCCH in a specific subframe.
7466  *               Note that this function is called only
7467  *               when PDCCH release needs to be made during
7468  *               uplink scheduling.
7469  *
7470  *     Invoked by: Scheduler
7471  *
7472  *  @param[in]  RgSchCellCb  *cell
7473  *  @param[in]  RgSchPdcch   *pdcch
7474  *  @return  Void
7475  **/
7476 #ifdef ANSI
7477 PUBLIC Void rgSCHCmnPdcchRlsCrntSf
7478 (
7479 RgSchCellCb                *cell,
7480 RgSchPdcch                 *pdcch
7481 )
7482 #else
7483 PUBLIC Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
7484 RgSchCellCb                *cell;
7485 RgSchPdcch                 *pdcch;
7486 #endif
7487 {
7488    CmLteTimingInfo      frm = cell->crntTime;
7489    RgSchDlSf               *sf;
7490
7491    TRC2(rgSCHCmnPdcchRlsCrntSf);
7492
7493    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
7494    sf = rgSCHUtlSubFrmGet(cell, frm);
7495    rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, pdcch);
7496    RETVOID;
7497 }
7498 /***********************************************************
7499  *
7500  *     Func : rgSCHCmnUlFillPdcchWithAlloc
7501  *
7502  *     Desc : Fills a PDCCH with format 0 information.
7503  *
7504  *     Ret  :
7505  *
7506  *     Notes:
7507  *
7508  *     File :
7509  *
7510  **********************************************************/
7511 #ifdef ANSI
7512 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc
7513 (
7514 RgSchPdcch      *pdcch,
7515 RgSchUlAlloc    *alloc,
7516 RgSchUeCb       *ue
7517 )
7518 #else
7519 PUBLIC Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
7520 RgSchPdcch      *pdcch;
7521 RgSchUlAlloc    *alloc;
7522 RgSchUeCb       *ue;
7523 #endif
7524 {
7525
7526    TRC2(rgSCHCmnUlFillPdcchWithAlloc);
7527
7528    pdcch->ue = ue;
7529    pdcch->rnti = alloc->rnti;
7530    //pdcch->dci.dciFormat = TFU_DCI_FORMAT_A2;
7531    pdcch->dci.dciFormat = alloc->grnt.dciFrmt;
7532
7533    //Currently hardcoding values here.
7534    //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
7535    switch(pdcch->dci.dciFormat)
7536    {
7537       case TFU_DCI_FORMAT_A1:
7538                 {
7539                         pdcch->dci.u.formatA1Info.formatType = 0;
7540          pdcch->dci.u.formatA1Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7541          pdcch->dci.u.formatA1Info.xPUSCH_TxTiming = 0;
7542          pdcch->dci.u.formatA1Info.RBAssign = alloc->grnt.rbAssign;
7543          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7544          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7545          pdcch->dci.u.formatA1Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7546          pdcch->dci.u.formatA1Info.CSI_BSI_BRI_Req = 0;
7547          pdcch->dci.u.formatA1Info.CSIRS_BRRS_TxTiming = 0;
7548          pdcch->dci.u.formatA1Info.CSIRS_BRRS_SymbIdx = 0;
7549          pdcch->dci.u.formatA1Info.CSIRS_BRRS_ProcInd = 0;
7550          pdcch->dci.u.formatA1Info.numBSI_Reports = 0;
7551          pdcch->dci.u.formatA1Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7552          pdcch->dci.u.formatA1Info.beamSwitch  = 0;
7553          pdcch->dci.u.formatA1Info.SRS_Config = 0;
7554          pdcch->dci.u.formatA1Info.SRS_Symbol = 0;
7555          pdcch->dci.u.formatA1Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7556          pdcch->dci.u.formatA1Info.SCID = alloc->grnt.SCID;
7557          pdcch->dci.u.formatA1Info.PMI = alloc->grnt.PMI;
7558          pdcch->dci.u.formatA1Info.UL_PCRS = 0;
7559          pdcch->dci.u.formatA1Info.tpcCmd = alloc->grnt.tpc;
7560                         break;
7561       }
7562                 case TFU_DCI_FORMAT_A2:
7563                 {
7564                         pdcch->dci.u.formatA2Info.formatType = 1;
7565          pdcch->dci.u.formatA2Info.xPUSCHRange = alloc->grnt.xPUSCHRange;
7566          pdcch->dci.u.formatA2Info.xPUSCH_TxTiming = 0;
7567          pdcch->dci.u.formatA2Info.RBAssign = alloc->grnt.rbAssign;
7568          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.hqProcId = alloc->grnt.hqProcId;
7569          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.mcs = alloc->grnt.iMcsCrnt;
7570          pdcch->dci.u.formatA2Info.u.rbAssignA1Val324.ndi = alloc->hqProc->ndi;
7571          pdcch->dci.u.formatA2Info.CSI_BSI_BRI_Req = 0;
7572          pdcch->dci.u.formatA2Info.CSIRS_BRRS_TxTiming = 0;
7573          pdcch->dci.u.formatA2Info.CSIRS_BRRS_SymbIdx = 0;
7574          pdcch->dci.u.formatA2Info.CSIRS_BRRS_ProcInd = 0;
7575          pdcch->dci.u.formatA2Info.numBSI_Reports = 0;
7576          pdcch->dci.u.formatA2Info.uciOnxPUSCH = alloc->grnt.uciOnxPUSCH;
7577          pdcch->dci.u.formatA2Info.beamSwitch  = 0;
7578          pdcch->dci.u.formatA2Info.SRS_Config = 0;
7579          pdcch->dci.u.formatA2Info.SRS_Symbol = 0;
7580          pdcch->dci.u.formatA2Info.REMapIdx_DMRS_PCRS_numLayers = 0;
7581          pdcch->dci.u.formatA2Info.SCID = alloc->grnt.SCID;
7582          pdcch->dci.u.formatA2Info.PMI = alloc->grnt.PMI;
7583          pdcch->dci.u.formatA2Info.UL_PCRS = 0;
7584          pdcch->dci.u.formatA2Info.tpcCmd = alloc->grnt.tpc;
7585                         break;
7586                 }
7587       default:
7588          RLOG1(L_ERROR," 5GTF_ERROR UL Allocator's icorrect "
7589                "dciForamt Fill RNTI:%d",alloc->rnti);
7590          break;
7591    }    
7592    
7593
7594    RETVOID;
7595 }
7596
7597 /***********************************************************
7598  *
7599  *     Func : rgSCHCmnUlAllocFillTpc
7600  *
7601  *     Desc : Determines and fills TPC for an UE allocation.
7602  *
7603  *     Ret  :
7604  *
7605  *     Notes:
7606  *
7607  *     File :
7608  *
7609  **********************************************************/
7610 #ifdef ANSI
7611 PUBLIC Void rgSCHCmnUlAllocFillTpc
7612 (
7613 RgSchCellCb  *cell,
7614 RgSchUeCb    *ue,
7615 RgSchUlAlloc *alloc
7616 )
7617 #else
7618 PUBLIC Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
7619 RgSchCellCb  *cell;
7620 RgSchUeCb    *ue;
7621 RgSchUlAlloc *alloc;
7622 #endif
7623 {
7624    TRC2(rgSCHCmnUlAllocFillTpc);
7625    alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
7626    RETVOID;
7627 }
7628
7629
7630 /***********************************************************
7631  *
7632  *     Func : rgSCHCmnAddUeToRefreshQ
7633  *
7634  *     Desc : Adds a UE to refresh queue, so that the UE is
7635  *            periodically triggered to refresh it's GBR and
7636  *            AMBR values.
7637  *
7638  *     Ret  :
7639  *
7640  *     Notes:
7641  *
7642  *     File :
7643  *
7644  **********************************************************/
7645 #ifdef ANSI
7646 PRIVATE Void rgSCHCmnAddUeToRefreshQ
7647 (
7648 RgSchCellCb     *cell,
7649 RgSchUeCb       *ue,
7650 U32             wait
7651 )
7652 #else
7653 PRIVATE Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
7654 RgSchCellCb     *cell;
7655 RgSchUeCb       *ue;
7656 U32             wait;
7657 #endif
7658 {
7659    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
7660    CmTmrArg       arg;
7661    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
7662
7663    TRC2(rgSCHCmnAddUeToRefreshQ);
7664    UNUSED(cell);
7665
7666    cmMemset((U8 *)&arg, 0, sizeof(arg));
7667    arg.tqCp   = &sched->tmrTqCp;
7668    arg.tq     = sched->tmrTq;
7669    arg.timers = &ueSchd->tmr;
7670    arg.cb     = (PTR)ue;
7671    arg.tNum   = 0;
7672    arg.max    = 1;
7673    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
7674    arg.wait   = wait;
7675    cmPlcCbTq(&arg);
7676    RETVOID;
7677 }
7678
7679 /**
7680  * @brief Perform UE reset procedure.
7681  *
7682  * @details
7683  *
7684  *     Function : rgSCHCmnUlUeReset
7685  *
7686  *     This functions performs BSR resetting and
7687  *     triggers UL specific scheduler
7688  *     to Perform UE reset procedure.
7689  *
7690  *  @param[in]  RgSchCellCb  *cell
7691  *  @param[in]  RgSchUeCb    *ue
7692  *  @return  Void
7693  **/
7694 #ifdef ANSI
7695 PRIVATE Void rgSCHCmnUlUeReset
7696 (
7697 RgSchCellCb  *cell,
7698 RgSchUeCb    *ue
7699 )
7700 #else
7701 PRIVATE Void rgSCHCmnUlUeReset(cell, ue)
7702 RgSchCellCb  *cell;
7703 RgSchUeCb    *ue;
7704 #endif
7705 {
7706    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7707    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7708    U8                   lcgCnt=0;
7709    RgSchCmnLcg          *lcgCmn;
7710    CmLList              *node;
7711    RgSchCmnAllocRecord  *allRcd;
7712    TRC2(rgSCHCmnUlUeReset);
7713
7714    ue->ul.minReqBytes = 0;
7715    ue->ul.totalBsr = 0;
7716    ue->ul.effBsr = 0;
7717    ue->ul.nonGbrLcgBs = 0;
7718    ue->ul.effAmbr = ue->ul.cfgdAmbr;
7719
7720    node = ueUl->ulAllocLst.first;
7721    while (node)
7722    {
7723       allRcd = (RgSchCmnAllocRecord *)node->node;
7724       allRcd->alloc = 0;
7725       node = node->next;
7726    }
7727    for(lcgCnt = 0; lcgCnt < RGSCH_MAX_LCG_PER_UE; lcgCnt++)
7728    {
7729       lcgCmn = RG_SCH_CMN_GET_UL_LCG(&ue->ul.lcgArr[lcgCnt]);
7730       lcgCmn->bs = 0;
7731       lcgCmn->reportedBs = 0;
7732       lcgCmn->effGbr = lcgCmn->cfgdGbr;
7733       lcgCmn->effDeltaMbr = lcgCmn->deltaMbr;
7734    }
7735    rgSCHCmnUlUeDelAllocs(cell, ue);
7736
7737    ue->isSrGrant = FALSE;
7738
7739    cellSchd->apisUl->rgSCHUlUeReset(cell, ue);
7740
7741    /* Stack Crash problem for TRACE5 changes. Added the return below */
7742    RETVOID;
7743
7744 }
7745
7746 /**
7747  * @brief RESET UL CQI and DL CQI&RI to conservative values
7748     * for a reestablishing UE.
7749  *
7750  * @details
7751  *
7752  *     Function : rgSCHCmnResetRiCqi 
7753  *     
7754  *     RESET UL CQI and DL CQI&RI to conservative values
7755  *     for a reestablishing UE
7756  *
7757  *  @param[in]  RgSchCellCb  *cell
7758  *  @param[in]  RgSchUeCb    *ue
7759  *  @return  Void
7760  **/
7761 #ifdef ANSI
7762 PRIVATE Void rgSCHCmnResetRiCqi 
7763 (
7764 RgSchCellCb  *cell,
7765 RgSchUeCb    *ue
7766 )
7767 #else
7768 PRIVATE Void rgSCHCmnResetRiCqi(cell, ue)
7769 RgSchCellCb  *cell;
7770 RgSchUeCb    *ue;
7771 #endif
7772 {
7773    RgSchCmnCell  *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7774    RgSchCmnUe    *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
7775    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7776    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
7777
7778    TRC2(rgSCHCmnResetRiCqi);
7779
7780    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, 
7781          cell->isCpUlExtend);
7782
7783    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
7784    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
7785    ueDl->mimoInfo.ri = 1;
7786    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
7787           (ue->mimoInfo.txMode == RGR_UE_TM_6))
7788    {
7789       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
7790    }
7791    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
7792    {
7793       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
7794    }
7795 #ifdef EMTC_ENABLE   
7796    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
7797 #else
7798    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
7799 #endif      
7800
7801 #ifdef TFU_UPGRADE
7802    /* Request for an early Aper CQI in case of reest */
7803    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
7804    if(acqiCb && acqiCb->aCqiCfg.pres)
7805    {
7806       acqiCb->aCqiTrigWt = 0;
7807    }
7808 #endif   
7809
7810    RETVOID;
7811 }
7812
7813 /**
7814  * @brief Perform UE reset procedure.
7815  *
7816  * @details
7817  *
7818  *     Function : rgSCHCmnDlUeReset
7819  *
7820  *     This functions performs BO resetting and
7821  *     triggers DL specific scheduler
7822  *     to Perform UE reset procedure.
7823  *
7824  *  @param[in]  RgSchCellCb  *cell
7825  *  @param[in]  RgSchUeCb    *ue
7826  *  @return  Void
7827  **/
7828 #ifdef ANSI
7829 PRIVATE Void rgSCHCmnDlUeReset
7830 (
7831 RgSchCellCb  *cell,
7832 RgSchUeCb    *ue
7833 )
7834 #else
7835 PRIVATE Void rgSCHCmnDlUeReset(cell, ue)
7836 RgSchCellCb  *cell;
7837 RgSchUeCb    *ue;
7838 #endif
7839 {
7840    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7841    RgSchCmnDlCell       *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
7842    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
7843
7844    TRC2(rgSCHCmnDlUeReset);
7845
7846    if (ueDl->rachInfo.poLnk.node != NULLP)
7847    {
7848       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
7849    }
7850
7851    /* Fix: syed Remove from TA List if this UE is there.
7852     * If TA Timer is running. Stop it */
7853    if (ue->dlTaLnk.node)
7854    {
7855       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
7856       ue->dlTaLnk.node = (PTR)NULLP;
7857    }
7858    else if (ue->taTmr.tmrEvnt != TMR_NONE)
7859    {
7860       rgSCHTmrStopTmr(cell, ue->taTmr.tmrEvnt, ue);
7861    }
7862
7863    cellSchd->apisDl->rgSCHDlUeReset(cell, ue);
7864 #ifdef LTE_ADV
7865    if (ue->numSCells)
7866    {
7867       rgSCHSCellDlUeReset(cell,ue);
7868    }
7869 #endif
7870 }
7871
7872 /**
7873  * @brief Perform UE reset procedure.
7874  *
7875  * @details
7876  *
7877  *     Function : rgSCHCmnUeReset
7878  *
7879  *     This functions triggers specific scheduler
7880  *     to Perform UE reset procedure.
7881  *
7882  *  @param[in]  RgSchCellCb  *cell
7883  *  @param[in]  RgSchUeCb    *ue
7884  *  @return  S16
7885  *      -# ROK
7886  *      -# RFAILED
7887  **/
7888 #ifdef ANSI
7889 PUBLIC Void rgSCHCmnUeReset
7890 (
7891 RgSchCellCb  *cell,
7892 RgSchUeCb    *ue
7893 )
7894 #else
7895 PUBLIC Void rgSCHCmnUeReset(cell, ue)
7896 RgSchCellCb  *cell;
7897 RgSchUeCb    *ue;
7898 #endif
7899 {
7900    U8 idx;
7901    Pst               pst;
7902    RgInfResetHqEnt   hqEntRstInfo;
7903
7904    TRC2(rgSCHCmnUeReset);
7905    /* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
7906    rgSCHCmnDelRachInfo(cell, ue);
7907
7908    rgSCHPwrUeReset(cell, ue);
7909
7910    rgSCHCmnUlUeReset(cell, ue);
7911    rgSCHCmnDlUeReset(cell, ue);
7912    
7913 #ifdef LTE_ADV
7914    /* Making allocCmnUlPdcch TRUE to allocate DCI0/1A from Common search space.
7915       As because multiple cells are added hence 2 bits CqiReq is there 
7916       This flag will be set to FALSE once we will get Scell READY */
7917    ue->allocCmnUlPdcch = TRUE;
7918 #endif
7919
7920    /* Fix : syed RESET UL CQI and DL CQI&RI to conservative values
7921     * for a reestablishing UE */
7922    /*Reset Cqi Config for all the configured cells*/
7923    for (idx = 0;idx < CM_LTE_MAX_CELLS; idx++)
7924    {
7925       if (ue->cellInfo[idx] != NULLP) 
7926       {   
7927          rgSCHCmnResetRiCqi(ue->cellInfo[idx]->cell, ue);
7928       }
7929    }
7930    /*After Reset Trigger APCQI for Pcell*/
7931    RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
7932    if(pCellInfo->acqiCb.aCqiCfg.pres)
7933    {
7934       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
7935    }
7936
7937 /* sending HqEnt reset to MAC */
7938    hqEntRstInfo.cellId = cell->cellId;
7939    hqEntRstInfo.crnti  = ue->ueId;
7940
7941    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
7942    RgSchMacRstHqEnt(&pst,&hqEntRstInfo);
7943
7944    RETVOID;
7945 }
7946
7947 /**
7948  * @brief UE out of MeasGap or AckNackReptn.
7949  *
7950  * @details
7951  *
7952  *     Function : rgSCHCmnActvtUlUe
7953  *
7954  *     This functions triggers specific scheduler
7955  *     to start considering it for scheduling.
7956  *
7957  *  @param[in]  RgSchCellCb  *cell
7958  *  @param[in]  RgSchUeCb    *ue
7959  *  @return  S16
7960  *      -# ROK
7961  *      -# RFAILED
7962  **/
7963 #ifdef ANSI
7964 PUBLIC Void rgSCHCmnActvtUlUe
7965 (
7966 RgSchCellCb  *cell,
7967 RgSchUeCb    *ue
7968 )
7969 #else
7970 PUBLIC Void rgSCHCmnActvtUlUe(cell, ue)
7971 RgSchCellCb  *cell;
7972 RgSchUeCb    *ue;
7973 #endif
7974 {
7975    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
7976    TRC2(rgSCHCmnActvtUlUe);
7977
7978    /* : take care of this in UL retransmission */
7979    cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
7980    RETVOID;
7981 }
7982
7983 /**
7984  * @brief UE out of MeasGap or AckNackReptn.
7985  *
7986  * @details
7987  *
7988  *     Function : rgSCHCmnActvtDlUe
7989  *
7990  *     This functions triggers specific scheduler
7991  *     to start considering it for scheduling.
7992  *
7993  *  @param[in]  RgSchCellCb  *cell
7994  *  @param[in]  RgSchUeCb    *ue
7995  *  @return  S16
7996  *      -# ROK
7997  *      -# RFAILED
7998  **/
7999 #ifdef ANSI
8000 PUBLIC Void rgSCHCmnActvtDlUe
8001 (
8002 RgSchCellCb  *cell,
8003 RgSchUeCb    *ue
8004 )
8005 #else
8006 PUBLIC Void rgSCHCmnActvtDlUe(cell, ue)
8007 RgSchCellCb  *cell;
8008 RgSchUeCb    *ue;
8009 #endif
8010 {
8011    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8012    TRC2(rgSCHCmnActvtDlUe);
8013
8014    cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
8015    RETVOID;
8016 }
8017
8018 /**
8019  * @brief This API is invoked to indicate scheduler of a CRC indication.
8020  *
8021  * @details
8022  *
8023  *     Function : rgSCHCmnHdlUlTransInd
8024  *      This API is invoked to indicate scheduler of a CRC indication.
8025  *
8026  *  @param[in]  RgSchCellCb     *cell
8027  *  @param[in]  RgSchUeCb       *ue
8028  *  @param[in]  CmLteTimingInfo timingInfo
8029  *
8030  *  @return Void
8031  **/
8032 #ifdef ANSI
8033 PUBLIC Void rgSCHCmnHdlUlTransInd
8034 (
8035 RgSchCellCb     *cell,
8036 RgSchUeCb       *ue,
8037 CmLteTimingInfo timingInfo
8038 )
8039 #else
8040 PUBLIC Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
8041 RgSchCellCb     *cell;
8042 RgSchUeCb       *ue;
8043 CmLteTimingInfo timingInfo;
8044 #endif
8045 {
8046    TRC2(rgSCHCmnHdlUlTransInd);
8047
8048    /* Update the latest UL dat/sig transmission time */
8049    RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
8050    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
8051    {
8052       /* Some UL Transmission from this UE.
8053        * Activate this UE if it was inactive */
8054       RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8055       RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
8056    }
8057    RETVOID;
8058 }
8059
8060 #ifdef TFU_UPGRADE
8061
8062 /**
8063  * @brief Compute the minimum Rank based on Codebook subset
8064  *        restriction configuration for 4 Tx Ports and Tx Mode 4.
8065  *
8066  * @details
8067  *
8068  *     Function : rgSCHCmnComp4TxMode4
8069  *
8070  *     Depending on BitMap set at CBSR during Configuration
8071  *      - return the least possible Rank
8072  *
8073  *
8074  *  @param[in]  U32 *pmiBitMap
8075  *  @return  RgSchCmnRank
8076  **/
8077 #ifdef ANSI
8078 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4
8079 (
8080  U32    *pmiBitMap
8081  )
8082 #else
8083 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
8084    U32  *pmiBitMap;
8085 #endif
8086 {
8087    U32 bitMap0, bitMap1;
8088    TRC2(rgSCHCmnComp4TxMode4);
8089    bitMap0 = pmiBitMap[0];
8090    bitMap1 = pmiBitMap[1];
8091    if((bitMap1) & 0xFFFF)
8092    {
8093       RETVALUE (RG_SCH_CMN_RANK_1);
8094    }
8095    else if((bitMap1>>16) & 0xFFFF)
8096    {
8097       RETVALUE (RG_SCH_CMN_RANK_2);
8098    }
8099    else if((bitMap0) & 0xFFFF)
8100    {
8101       RETVALUE (RG_SCH_CMN_RANK_3);
8102    }
8103    else if((bitMap0>>16) & 0xFFFF)
8104    {
8105       RETVALUE (RG_SCH_CMN_RANK_4);
8106    }
8107    else
8108    {
8109       RETVALUE (RG_SCH_CMN_RANK_1);
8110    }
8111 }
8112
8113
8114 /**
8115  * @brief Compute the minimum Rank based on Codebook subset
8116  *        restriction configuration for 2 Tx Ports and Tx Mode 4.
8117  *
8118  * @details
8119  *
8120  *     Function : rgSCHCmnComp2TxMode4
8121  *
8122  *     Depending on BitMap set at CBSR during Configuration
8123  *      - return the least possible Rank
8124  *
8125  *
8126  *  @param[in]  U32 *pmiBitMap
8127  *  @return  RgSchCmnRank
8128  **/
8129 #ifdef ANSI
8130 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4
8131 (
8132  U32    *pmiBitMap
8133  )
8134 #else
8135 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
8136    U32  *pmiBitMap;
8137 #endif
8138 {
8139    U32 bitMap0;
8140    TRC2(rgSCHCmnComp2TxMode4);
8141    bitMap0 = pmiBitMap[0];
8142    if((bitMap0>>26)& 0x0F)
8143    {
8144       RETVALUE (RG_SCH_CMN_RANK_1);
8145    }
8146    else if((bitMap0>>30) & 3)
8147    {
8148       RETVALUE (RG_SCH_CMN_RANK_2);
8149    }
8150    else
8151    {
8152       RETVALUE (RG_SCH_CMN_RANK_1);
8153    }
8154 }
8155
8156 /**
8157  * @brief Compute the minimum Rank based on Codebook subset
8158  *        restriction configuration for 4 Tx Ports and Tx Mode 3.
8159  *
8160  * @details
8161  *
8162  *     Function : rgSCHCmnComp4TxMode3
8163  *
8164  *     Depending on BitMap set at CBSR during Configuration
8165  *      - return the least possible Rank
8166  *
8167  *
8168  *  @param[in]  U32 *pmiBitMap
8169  *  @return  RgSchCmnRank
8170  **/
8171 #ifdef ANSI
8172 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3
8173 (
8174  U32    *pmiBitMap
8175  )
8176 #else
8177 PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
8178    U32  *pmiBitMap;
8179 #endif
8180 {
8181    U32 bitMap0;
8182    TRC2(rgSCHCmnComp4TxMode3);
8183    bitMap0 = pmiBitMap[0];
8184    if((bitMap0>>28)& 1)
8185    {
8186       RETVALUE (RG_SCH_CMN_RANK_1);
8187    }
8188    else if((bitMap0>>29) &1)
8189    {
8190       RETVALUE (RG_SCH_CMN_RANK_2);
8191    }
8192    else if((bitMap0>>30) &1)
8193    {
8194       RETVALUE (RG_SCH_CMN_RANK_3);
8195    }
8196    else if((bitMap0>>31) &1)
8197    {
8198       RETVALUE (RG_SCH_CMN_RANK_4);
8199    }
8200    else
8201    {
8202       RETVALUE (RG_SCH_CMN_RANK_1);
8203    }
8204 }
8205
8206 /**
8207  * @brief Compute the minimum Rank based on Codebook subset
8208  *        restriction configuration for 2 Tx Ports and Tx Mode 3.
8209  *
8210  * @details
8211  *
8212  *     Function : rgSCHCmnComp2TxMode3
8213  *
8214  *     Depending on BitMap set at CBSR during Configuration
8215  *      - return the least possible Rank
8216  *
8217  *
8218  *  @param[in]  U32 *pmiBitMap
8219  *  @return  RgSchCmnRank
8220  **/
8221 #ifdef ANSI
8222 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3
8223 (
8224  U32 *pmiBitMap
8225  )
8226 #else
8227 PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
8228    U32 *pmiBitMap;
8229 #endif
8230 {
8231    U32 bitMap0;
8232    TRC2(rgSCHCmnComp2TxMode3);
8233    bitMap0 = pmiBitMap[0];
8234    if((bitMap0>>30)& 1)
8235    {
8236       RETVALUE (RG_SCH_CMN_RANK_1);
8237    }
8238    else if((bitMap0>>31) &1)
8239    {
8240       RETVALUE (RG_SCH_CMN_RANK_2);
8241    }
8242    else
8243    {
8244       RETVALUE (RG_SCH_CMN_RANK_1);
8245    }
8246 }
8247
8248 /**
8249  * @brief Compute the minimum Rank based on Codebook subset
8250  *        restriction configuration.
8251  *
8252  * @details
8253  *
8254  *     Function : rgSCHCmnComputeRank
8255  *
8256  *     Depending on Num Tx Ports and Transmission mode
8257  *      - return the least possible Rank
8258  *
8259  *
8260  *  @param[in]  RgrTxMode txMode
8261  *  @param[in]  U32 *pmiBitMap
8262  *  @param[in]  U8 numTxPorts
8263  *  @return  RgSchCmnRank
8264  **/
8265 #ifdef ANSI
8266 PRIVATE RgSchCmnRank rgSCHCmnComputeRank
8267 (
8268  RgrTxMode    txMode,
8269  U32          *pmiBitMap,
8270  U8           numTxPorts
8271  )
8272 #else
8273 PRIVATE RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
8274    RgrTxMode    txMode;
8275    U32          *pmiBitMap;
8276    U8           numTxPorts;
8277 #endif
8278 {
8279    TRC2(rgSCHCmnComputeRank);
8280
8281    if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
8282    {
8283       RETVALUE (rgSCHCmnComp2TxMode3(pmiBitMap));
8284    }
8285    else if (numTxPorts ==4 && txMode == RGR_UE_TM_3)
8286    {
8287       RETVALUE (rgSCHCmnComp4TxMode3(pmiBitMap));
8288    }
8289    else if (numTxPorts ==2 && txMode == RGR_UE_TM_4)
8290    {
8291       RETVALUE (rgSCHCmnComp2TxMode4(pmiBitMap));
8292    }
8293    else if (numTxPorts ==4 && txMode == RGR_UE_TM_4)
8294    {
8295       RETVALUE (rgSCHCmnComp4TxMode4(pmiBitMap));
8296    }
8297    else
8298    {
8299       RETVALUE (RG_SCH_CMN_RANK_1);
8300    }
8301 }
8302
8303 #endif
8304
8305 /**
8306  * @brief Harq Entity Deinitialization for CMN SCH.
8307  *
8308  * @details
8309  *
8310  *     Function : rgSCHCmnDlDeInitHqEnt 
8311  *
8312  *     Harq Entity Deinitialization for CMN SCH 
8313  *
8314  *  @param[in]  RgSchCellCb  *cell
8315  *  @param[in]  RgSchDlHqEnt *hqE 
8316  *  @return  VOID
8317  **/
8318 /*KWORK_FIX:Changed function return type to void */
8319 #ifdef ANSI
8320 PUBLIC Void rgSCHCmnDlDeInitHqEnt 
8321 (
8322 RgSchCellCb  *cell,
8323 RgSchDlHqEnt *hqE
8324 )
8325 #else
8326 PUBLIC Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
8327 RgSchCellCb  *cell;
8328 RgSchDlHqEnt *hqE;
8329 #endif
8330 {
8331    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8332    RgSchDlHqProcCb      *hqP;
8333    U8                   cnt;
8334    S16                  ret;
8335
8336    TRC2(rgSCHCmnDlDeInitHqEnt);
8337
8338    ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
8339    /* Free only If the Harq proc are created*/
8340    if(RFAILED == ret)
8341    {
8342    }
8343
8344    for(cnt = 0; cnt < hqE->numHqPrcs; cnt++)
8345    {
8346       hqP = &hqE->procs[cnt];
8347       if ((RG_SCH_CMN_GET_DL_HQP(hqP)))
8348       {
8349          rgSCHUtlFreeSBuf(cell->instIdx,
8350               (Data**)(&(hqP->sch)), (sizeof(RgSchCmnDlHqProc)));
8351       }
8352    }
8353 #ifdef LTE_ADV
8354    rgSCHLaaDeInitDlHqProcCb (cell, hqE);
8355 #endif
8356
8357    RETVOID;
8358 }
8359
8360 /**
8361  * @brief Harq Entity initialization for CMN SCH.
8362  *
8363  * @details
8364  *
8365  *     Function : rgSCHCmnDlInitHqEnt 
8366  *
8367  *     Harq Entity initialization for CMN SCH 
8368  *
8369  *  @param[in]  RgSchCellCb  *cell
8370  *  @param[in]  RgSchUeCb    *ue
8371  *  @return  S16
8372  *      -# ROK
8373  *      -# RFAILED
8374  **/
8375 #ifdef ANSI
8376 PUBLIC S16 rgSCHCmnDlInitHqEnt 
8377 (
8378 RgSchCellCb  *cell,
8379 RgSchDlHqEnt  *hqEnt
8380 )
8381 #else
8382 PUBLIC S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
8383 RgSchCellCb  *cell;
8384 RgSchDlHqEnt  *hqEnt;
8385 #endif
8386
8387 {
8388    RgSchDlHqProcCb      *hqP;
8389    U8                   cnt;
8390
8391    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8392    TRC2(rgSCHCmnDlInitHqEnt);
8393
8394    for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
8395    {
8396       hqP = &hqEnt->procs[cnt];
8397       if (rgSCHUtlAllocSBuf(cell->instIdx,
8398                (Data**)&(hqP->sch), (sizeof(RgSchCmnDlHqProc))) != ROK)
8399       {
8400          RETVALUE(RFAILED);
8401       }
8402    }
8403 #ifdef EMTC_ENABLE
8404    if((cell->emtcEnable) &&(hqEnt->ue->isEmtcUe))
8405    {
8406       if(ROK != cellSchd->apisEmtcDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8407       {
8408          RETVALUE(RFAILED);
8409       }
8410
8411    }
8412    else
8413 #endif
8414    {
8415       if(ROK != cellSchd->apisDl->rgSCHDlUeHqEntInit(cell, hqEnt))
8416       {
8417          RETVALUE(RFAILED);
8418       }
8419    }
8420
8421    RETVALUE(ROK);
8422 }  /* rgSCHCmnDlInitHqEnt */
8423
8424 /**
8425  * @brief This function computes distribution of refresh period
8426  *
8427  * @details
8428  *
8429  *     Function: rgSCHCmnGetRefreshDist 
8430  *     Purpose: This function computes distribution of refresh period
8431  *              This is required to align set of UEs refresh
8432  *              around the different consecutive subframe.
8433  *               
8434  *     Invoked by: rgSCHCmnGetRefreshPerDist
8435  *
8436  *  @param[in]  RgSchCellCb        *cell
8437  *  @param[in]  RgSchUeCb          *ue
8438  *  @return  Void
8439  *
8440  **/
8441 #ifdef ANSI
8442 PRIVATE U8 rgSCHCmnGetRefreshDist 
8443 (
8444 RgSchCellCb        *cell,
8445 RgSchUeCb          *ue
8446 )
8447 #else
8448 PRIVATE U8 rgSCHCmnGetRefreshDist(cell, ue)
8449 RgSchCellCb        *cell;
8450 RgSchUeCb          *ue;
8451 #endif
8452 {
8453    U8   refOffst;
8454 #ifdef DEBUGP
8455    Inst inst = cell->instIdx;
8456 #endif
8457    TRC2(rgSCHCmnGetRefreshDist);
8458
8459    for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
8460    {
8461       if(cell->refreshUeCnt[refOffst] < RGSCH_MAX_REFRESH_GRPSZ)
8462       {
8463          cell->refreshUeCnt[refOffst]++;
8464          ue->refreshOffset = refOffst;
8465          /* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst,  cell->refreshUeCnt[refOffst]); */
8466          RETVALUE(refOffst);
8467       }
8468    }
8469   
8470    RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Allocation of refresh distribution failed\n"));
8471    /* We should not enter here  normally, but incase of failure, allocating from  last offset*/
8472    cell->refreshUeCnt[refOffst-1]++;
8473    ue->refreshOffset = refOffst-1;
8474
8475    RETVALUE(refOffst-1);
8476 }
8477 /**
8478  * @brief This function computes initial Refresh Wait Period.
8479  *
8480  * @details
8481  *
8482  *     Function: rgSCHCmnGetRefreshPer 
8483  *     Purpose: This function computes initial Refresh Wait Period.
8484  *              This is required to align multiple UEs refresh
8485  *              around the same time.
8486  *               
8487  *     Invoked by: rgSCHCmnGetRefreshPer 
8488  *
8489  *  @param[in]  RgSchCellCb        *cell
8490  *  @param[in]  RgSchUeCb          *ue
8491  *  @param[in]  U32                *waitPer 
8492  *  @return  Void
8493  *
8494  **/
8495 #ifdef ANSI
8496 PRIVATE Void rgSCHCmnGetRefreshPer 
8497 (
8498 RgSchCellCb        *cell,
8499 RgSchUeCb          *ue,
8500 U32                *waitPer
8501 )
8502 #else
8503 PRIVATE Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
8504 RgSchCellCb        *cell;
8505 RgSchUeCb          *ue;
8506 U32                *waitPer;
8507 #endif
8508 {
8509    U32       refreshPer;           
8510    U32       crntSubFrm;
8511
8512    TRC2(rgSCHCmnGetRefreshPer);     
8513
8514    refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
8515    crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
8516    /* Fix: syed align multiple UEs to refresh at same time */
8517    *waitPer = refreshPer - (crntSubFrm % refreshPer);
8518    *waitPer = RGSCH_CEIL(*waitPer, RG_SCH_CMN_REFRESH_TIMERES);
8519    *waitPer = *waitPer + rgSCHCmnGetRefreshDist(cell, ue);
8520
8521    RETVOID;
8522 }
8523
8524
8525 #ifdef LTE_ADV
8526 /**
8527  * @brief UE initialisation for scheduler.
8528  *
8529  * @details
8530  *
8531  *     Function : rgSCHCmnRgrSCellUeCfg
8532  *
8533  *     This functions intialises UE specific scheduler 
8534  *     information for SCELL
8535  *     0. Perform basic validations
8536  *     1. Allocate common sched UE cntrl blk
8537  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8538  *     3. Perform UL cfg
8539  *     4. Perform DLFS cfg
8540  *
8541  *  @param[in]  RgSchCellCb  *cell
8542  *  @param[in]  RgSchUeCb    *ue
8543  *  @param[out] RgSchErrInfo *err
8544  *  @return  S16
8545  *      -# ROK
8546  *      -# RFAILED
8547  **/
8548 #ifdef ANSI
8549 PUBLIC S16 rgSCHCmnRgrSCellUeCfg
8550 (
8551 RgSchCellCb  *sCell,
8552 RgSchUeCb    *ue,
8553 RgrUeSecCellCfg  *sCellInfoCfg,
8554 RgSchErrInfo *err
8555 )
8556 #else
8557 PUBLIC S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
8558 RgSchCellCb  *sCell;
8559 RgSchUeCb    *ue;
8560 RgrUeSecCellCfg  *sCellInfoCfg;
8561 RgSchErrInfo *err;
8562 #endif
8563 {
8564    U8 i;
8565    S16                  ret;
8566    U8                   cnt;
8567    RgSchCmnAllocRecord  *allRcd;
8568    RgSchDlRbAlloc       *allocInfo;
8569    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8570    RgSchCmnUlUe         *ueUl;
8571    RgSchCmnUlUe         *ueUlPcell;
8572    RgSchCmnUe           *pCellUeSchCmn;
8573    RgSchCmnUe           *ueSchCmn;
8574    RgSchCmnDlUe         *ueDl;
8575    RgSchCmnDlUe         *pCellUeDl;
8576 #ifdef DEBUGP
8577    Inst                 inst = ue->cell->instIdx;
8578 #endif
8579    U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8580    TRC2(rgSCHCmnRgrSCellUeCfg);
8581
8582    pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
8583    pCellUeDl = &pCellUeSchCmn->dl;
8584
8585    /* 1. Allocate Common sched control block */
8586    if((rgSCHUtlAllocSBuf(sCell->instIdx,
8587                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8588    {
8589       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
8590       err->errCause = RGSCHERR_SCH_CFG;
8591       RETVALUE(RFAILED);
8592    }
8593    ueSchCmn = RG_SCH_CMN_GET_UE(ue,sCell);
8594
8595    /*2.  Perform UEs downlink configuration */
8596    ueDl = &ueSchCmn->dl;
8597
8598    /*CA TODO*/
8599    ueDl->mimoInfo = pCellUeDl->mimoInfo;
8600
8601    if ((ue->mimoInfo.txMode == RGR_UE_TM_4) ||
8602          (ue->mimoInfo.txMode == RGR_UE_TM_6))
8603    {
8604       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_NO_PMI);
8605    }
8606    if (ue->mimoInfo.txMode == RGR_UE_TM_3)
8607    {
8608       RG_SCH_CMN_SET_FORCE_TD(ue, sCell, RG_SCH_CMN_TD_RI_1);
8609    }
8610    RGSCH_ARRAY_BOUND_CHECK(sCell->instIdx, rgUeCatTbl, pCellUeSchCmn->cmn.ueCat);
8611    ueDl->maxTbBits = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlTbBits;
8612    /*CA dev-Start*/
8613    U8 ri = 0;
8614    ri = RGSCH_MIN(ri, sCell->numTxAntPorts);
8615    if(((CM_LTE_UE_CAT_6 == pCellUeSchCmn->cmn.ueCat )
8616             ||(CM_LTE_UE_CAT_7 == pCellUeSchCmn->cmn.ueCat)) 
8617          && (4 == ri))
8618    {
8619       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[1];
8620    }
8621    else
8622    {
8623       ueDl->maxTbSz = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlBits[0];
8624    }
8625    /*CA dev-End*/
8626    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
8627 #ifdef LTE_TDD
8628    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8629          rgSchTddDlNumHarqProcTbl[sCell->ulDlCfgIdx]);
8630 #else
8631    ueDl->maxSbSz = (rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxSftChBits/
8632          RGSCH_NUM_DL_HQ_PROC);
8633 #endif
8634 #ifdef EMTC_ENABLE   
8635    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, ue->isEmtcUe);
8636 #else
8637    rgSCHCmnDlSetUeAllocLmt(sCell, ueDl, FALSE);
8638 #endif      
8639
8640    /* DL ambr */
8641    /* ambrCfgd config moved to ueCb.dl, as it's not needed for per cell wise*/
8642
8643    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, sCell);
8644    allocInfo->rnti = ue->ueId;
8645
8646    /* Initializing the lastCfi value to current cfi value */
8647    ueDl->lastCfi = cellSchd->dl.currCfi;
8648
8649    if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
8650    {
8651       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
8652       RETVALUE(RFAILED);
8653    }
8654
8655    /* TODO: enhance for DLFS RB Allocation for SCELLs in future dev */
8656
8657    /* DLFS UE Config */
8658    if (cellSchd->dl.isDlFreqSel)
8659    {
8660       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
8661       {
8662          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
8663          RETVALUE(RFAILED);
8664       }
8665    }
8666
8667    /* TODO: Do UL SCELL CFG during UL CA dev */
8668    {
8669       ueUl = RG_SCH_CMN_GET_UL_UE(ue, sCell);
8670
8671       /* TODO_ULCA: SRS for SCELL needs to be handled in the below function call */
8672       rgSCHCmnUpdUeUlCqiInfo(sCell, ue, ueUl, ueSchCmn, cellSchd,
8673             sCell->isCpUlExtend);
8674
8675       ret = rgSCHUhmHqEntInit(sCell, ue);
8676       if (ret != ROK)
8677       {
8678          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
8679                "Failed for CRNTI:%d", ue->ueId);
8680          RETVALUE(RFAILED);
8681       }
8682
8683       ueUlPcell = RG_SCH_CMN_GET_UL_UE(ue, ue->cell);
8684       /* Initialize uplink HARQ related information for UE */
8685       ueUl->hqEnt.maxHqRetx = ueUlPcell->hqEnt.maxHqRetx;
8686       cmLListInit(&ueUl->hqEnt.free);
8687       cmLListInit(&ueUl->hqEnt.inUse);
8688       for(i=0; i < ueUl->hqEnt.numHqPrcs; i++)
8689       {
8690          ueUl->hqEnt.hqProcCb[i].hqEnt = (void*)(&ueUl->hqEnt);
8691          ueUl->hqEnt.hqProcCb[i].procId = i;
8692          ueUl->hqEnt.hqProcCb[i].ulSfIdx = RGSCH_INVALID_INFO;
8693          ueUl->hqEnt.hqProcCb[i].alloc = NULLP;
8694 #ifdef LTEMAC_SPS
8695          /* ccpu00139513- Initializing SPS flags*/
8696          ueUl->hqEnt.hqProcCb[i].isSpsActvnHqP = FALSE;
8697          ueUl->hqEnt.hqProcCb[i].isSpsOccnHqP = FALSE;
8698 #endif
8699          cmLListAdd2Tail(&ueUl->hqEnt.free, &ueUl->hqEnt.hqProcCb[i].lnk);
8700          ueUl->hqEnt.hqProcCb[i].lnk.node = (PTR)&ueUl->hqEnt.hqProcCb[i];
8701       }
8702
8703       /* Allocate UL BSR allocation tracking List */
8704       cmLListInit(&ueUl->ulAllocLst);
8705
8706       for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
8707       {
8708          if((rgSCHUtlAllocSBuf(sCell->instIdx,
8709                      (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
8710          {
8711             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
8712                   "for CRNTI:%d",ue->ueId);
8713             err->errCause = RGSCHERR_SCH_CFG;
8714             RETVALUE(RFAILED);
8715          }
8716          allRcd->allocTime = sCell->crntTime;
8717          cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
8718          allRcd->lnk.node = (PTR)allRcd;
8719       }
8720
8721       /* After initialising UL part, do power related init */
8722       ret = rgSCHPwrUeSCellCfg(sCell, ue, sCellInfoCfg);
8723       if (ret != ROK)
8724       {
8725          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
8726                "power config for UE CRNTI:%d",ue->ueId);
8727          RETVALUE(RFAILED);
8728       }
8729
8730 #ifdef EMTC_ENABLE   
8731       if(TRUE == ue->isEmtcUe)
8732       {
8733          if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8734          {
8735             RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8736                   "for CRNTI:%d",ue->ueId);
8737             RETVALUE(RFAILED);
8738          }
8739       }
8740       else
8741 #endif
8742       {
8743       if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
8744       {
8745          RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
8746                "for CRNTI:%d",ue->ueId);
8747          RETVALUE(RFAILED);
8748       }
8749       }
8750    
8751       ue->ul.isUlCaEnabled = TRUE;
8752    }
8753
8754    RETVALUE(ROK);
8755 }  /* rgSCHCmnRgrSCellUeCfg */
8756
8757
8758 /**
8759  * @brief UE initialisation for scheduler.
8760  *
8761  * @details
8762  *
8763  *     Function : rgSCHCmnRgrSCellUeDel 
8764  *
8765  *     This functions Delete UE specific scheduler 
8766  *     information for SCELL
8767  *
8768  *  @param[in]  RgSchCellCb  *cell
8769  *  @param[in]  RgSchUeCb    *ue
8770  *  @return  S16
8771  *      -# ROK
8772  *      -# RFAILED
8773  **/
8774 #ifdef ANSI
8775 PUBLIC S16 rgSCHCmnRgrSCellUeDel
8776 (
8777 RgSchUeCellInfo *sCellInfo,
8778 RgSchUeCb    *ue
8779 )
8780 #else
8781 PUBLIC S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
8782 RgSchUeCellInfo *sCellInfo;
8783 RgSchUeCb    *ue;
8784 #endif
8785 {
8786    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
8787    Inst                 inst = ue->cell->instIdx;
8788
8789    TRC2(rgSCHCmnRgrSCellUeDel);
8790
8791    cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
8792
8793    /* UL CA */
8794    rgSCHCmnUlUeDelAllocs(sCellInfo->cell, ue);
8795
8796 #ifdef EMTC_ENABLE   
8797    if(TRUE == ue->isEmtcUe)
8798    {
8799       cellSchd->apisEmtcUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8800    }
8801    else
8802 #endif
8803    {
8804    cellSchd->apisUl->rgSCHFreeUlUe(sCellInfo->cell, ue);
8805    }
8806
8807    /* DLFS UE Config */
8808    if (cellSchd->dl.isDlFreqSel)
8809    {
8810       if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
8811       {
8812          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
8813          RETVALUE(RFAILED);
8814       }
8815    }
8816
8817    rgSCHUtlFreeSBuf(sCellInfo->cell->instIdx,
8818          (Data**)(&(sCellInfo->sch)), (sizeof(RgSchCmnUe)));
8819
8820
8821    RETVALUE(ROK);
8822 }  /* rgSCHCmnRgrSCellUeDel */
8823  
8824 #endif
8825
8826 #ifdef RG_5GTF
8827 /**
8828  * @brief Handles 5gtf configuration for a UE
8829  *
8830  * @details
8831  *
8832  *     Function : rgSCHCmn5gtfUeCfg
8833  *
8834  *     Processing Steps:
8835  *
8836  *      - Return ROK
8837  *
8838  *  @param[in]  RgSchCellCb  *cell
8839  *  @param[in]  RgSchUeCb    *ue
8840  *  @param[in]  RgrUeCfg     *cfg
8841  *  @return  S16
8842  *      -# ROK
8843  *      -# RFAILED
8844  **/
8845 #ifdef ANSI
8846 PUBLIC S16 rgSCHCmn5gtfUeCfg
8847 (
8848 RgSchCellCb *cell,
8849 RgSchUeCb   *ue,
8850 RgrUeCfg    *cfg
8851 )
8852 #else
8853 PUBLIC S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
8854 RgSchCellCb *cell;
8855 RgSchUeCb   *ue;
8856 RgrUeCfg    *cfg;
8857 #endif
8858 {
8859    TRC2(rgSCHCmnRgrUeCfg);
8860
8861    RgSchUeGrp *ue5gtfGrp;
8862    ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
8863    ue->ue5gtfCb.BeamId = cfg->ue5gtfCfg.BeamId;
8864    ue->ue5gtfCb.numCC = cfg->ue5gtfCfg.numCC;   
8865    ue->ue5gtfCb.mcs = cfg->ue5gtfCfg.mcs;
8866    ue->ue5gtfCb.maxPrb = cfg->ue5gtfCfg.maxPrb;
8867
8868    ue->ue5gtfCb.cqiRiPer = 100;
8869    /* 5gtf TODO: CQIs to start from (10,0)*/
8870    ue->ue5gtfCb.nxtCqiRiOccn.sfn = 10;
8871    ue->ue5gtfCb.nxtCqiRiOccn.slot = 0;
8872    ue->ue5gtfCb.rank = 1;
8873
8874    printf("\nschd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
8875          ue->ue5gtfCb.mcs,ue->ue5gtfCb.maxPrb); 
8876
8877    ue5gtfGrp = &(cell->cell5gtfCb.ueGrp5gConf[ue->ue5gtfCb.BeamId]);
8878
8879    /* TODO_5GTF: Currently handling 1 group only. Need to update when multi group 
8880       scheduling comes into picture */
8881    if(ue5gtfGrp->beamBitMask & (1 << ue->ue5gtfCb.BeamId))
8882    {
8883       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8884             "5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
8885       RETVALUE(RFAILED);
8886    }
8887    ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
8888
8889    RETVALUE(ROK);
8890 }
8891 #endif
8892
8893 /**
8894  * @brief UE initialisation for scheduler.
8895  *
8896  * @details
8897  *
8898  *     Function : rgSCHCmnRgrUeCfg
8899  *
8900  *     This functions intialises UE specific scheduler
8901  *     information
8902  *     0. Perform basic validations
8903  *     1. Allocate common sched UE cntrl blk
8904  *     2. Perform DL cfg (allocate Hq Procs Cmn sched cntrl blks)
8905  *     3. Perform UL cfg
8906  *     4. Perform DLFS cfg
8907  *
8908  *  @param[in]  RgSchCellCb  *cell
8909  *  @param[in]  RgSchUeCb    *ue
8910  *  @param[int] RgrUeCfg     *ueCfg
8911  *  @param[out] RgSchErrInfo *err
8912  *  @return  S16
8913  *      -# ROK
8914  *      -# RFAILED
8915  **/
8916 #ifdef ANSI
8917 PUBLIC S16 rgSCHCmnRgrUeCfg
8918 (
8919 RgSchCellCb  *cell,
8920 RgSchUeCb    *ue,
8921 RgrUeCfg     *ueCfg,
8922 RgSchErrInfo *err
8923 )
8924 #else
8925 PUBLIC S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
8926 RgSchCellCb  *cell;
8927 RgSchUeCb    *ue;
8928 RgrUeCfg     *ueCfg;
8929 RgSchErrInfo *err;
8930 #endif
8931 {
8932    RgSchDlRbAlloc  *allocInfo;
8933    S16                  ret;
8934    RgSchCmnCell         *cellSchd = RG_SCH_CMN_GET_CELL(cell);
8935    RgSchCmnUe           *ueSchCmn;
8936    RgSchCmnUlUe         *ueUl;
8937    RgSchCmnDlUe         *ueDl;
8938    U8                   cnt;
8939    RgSchCmnAllocRecord  *allRcd;
8940    U32                  waitPer;
8941    U32                  idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
8942    RgSchUeCellInfo      *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
8943    TRC2(rgSCHCmnRgrUeCfg);
8944
8945
8946    /* 1. Allocate Common sched control block */
8947    if((rgSCHUtlAllocSBuf(cell->instIdx,
8948                (Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
8949    {
8950       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
8951             "Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
8952       err->errCause = RGSCHERR_SCH_CFG;
8953       RETVALUE(RFAILED);
8954    }
8955    ueSchCmn   = RG_SCH_CMN_GET_UE(ue,cell);
8956    ue->dl.ueDlCqiCfg = ueCfg->ueDlCqiCfg;
8957    pCellInfo->acqiCb.aCqiCfg = ueCfg->ueDlCqiCfg.aprdCqiCfg;
8958    if(ueCfg->ueCatEnum > 0 )
8959    {
8960      /*KWORK_FIX removed NULL chk for ueSchCmn*/
8961       ueSchCmn->cmn.ueCat = ueCfg->ueCatEnum - 1; 
8962    }
8963    else
8964    {
8965       ueSchCmn->cmn.ueCat = 0; /* Assuming enum values correctly set */
8966    }
8967    cmInitTimers(&ueSchCmn->cmn.tmr, 1);
8968
8969    /*2.  Perform UEs downlink configuration */
8970    ueDl = &ueSchCmn->dl;
8971    /* RACHO : store the rapId assigned for HandOver UE.
8972     * Append UE to handover list of cmnCell */
8973    if (ueCfg->dedPreambleId.pres == PRSNT_NODEF)
8974    {
8975       rgSCHCmnDelDedPreamble(cell, ueCfg->dedPreambleId.val);
8976       ueDl->rachInfo.hoRapId = ueCfg->dedPreambleId.val;
8977       cmLListAdd2Tail(&cellSchd->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
8978       ueDl->rachInfo.hoLnk.node = (PTR)ue;
8979    }
8980
8981    rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd);
8982
8983    if (ueCfg->txMode.pres == TRUE)
8984    {
8985       if ((ueCfg->txMode.txModeEnum == RGR_UE_TM_4) ||
8986             (ueCfg->txMode.txModeEnum == RGR_UE_TM_6))
8987       {
8988          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
8989       }
8990       if (ueCfg->txMode.txModeEnum == RGR_UE_TM_3)
8991       {
8992          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
8993       }
8994    }
8995    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
8996    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
8997    /*CA dev-Start*/
8998    U8 ri = 0;
8999    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
9000    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
9001             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9002                   && (4 == ri))
9003    {
9004       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9005    }
9006    else
9007    {
9008       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9009    }
9010    /*CA dev-End*/
9011    /* Fix : syed Assign hqEnt to UE only if msg4 is done */
9012 #ifdef LTE_TDD
9013    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9014          rgSchTddDlNumHarqProcTbl[cell->ulDlCfgIdx]);
9015 #else
9016    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9017          RGSCH_NUM_DL_HQ_PROC);
9018 #endif
9019 #ifdef EMTC_ENABLE   
9020    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, ue->isEmtcUe);
9021 #else
9022    rgSCHCmnDlSetUeAllocLmt(cell, ueDl, FALSE);
9023 #endif 
9024      /* if none of the DL and UL AMBR are configured then fail the configuration
9025     */     
9026    if((ueCfg->ueQosCfg.dlAmbr == 0) && (ueCfg->ueQosCfg.ueBr == 0))
9027    {
9028       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
9029          "configured as 0 for CRNTI:%d",ueCfg->crnti);
9030       err->errCause = RGSCHERR_SCH_CFG;
9031       RETVALUE(RFAILED);
9032    }
9033    /* DL ambr */
9034    ue->dl.ambrCfgd = (ueCfg->ueQosCfg.dlAmbr * RG_SCH_CMN_REFRESH_TIME)/100;
9035
9036    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
9037    allocInfo->rnti = ue->ueId;
9038
9039    /* Initializing the lastCfi value to current cfi value */
9040    ueDl->lastCfi = cellSchd->dl.currCfi;
9041 #ifdef EMTC_ENABLE
9042    if(cell->emtcEnable && ue->isEmtcUe)
9043    {
9044       if ((cellSchd->apisEmtcDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9045       {
9046          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9047                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9048          RETVALUE(RFAILED);
9049       }
9050
9051    }
9052    else
9053 #endif
9054    {
9055       if ((cellSchd->apisDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
9056       {
9057          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9058                "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
9059          RETVALUE(RFAILED);
9060       }
9061    }
9062
9063
9064
9065    /* 3. Initialize ul part */
9066    ueUl     = &ueSchCmn->ul;
9067
9068    rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
9069             cell->isCpUlExtend);
9070
9071    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9072                                RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9073
9074    ue->ul.cfgdAmbr = (ueCfg->ueQosCfg.ueBr * RG_SCH_CMN_REFRESH_TIME)/100;
9075    ue->ul.effAmbr = ue->ul.cfgdAmbr;
9076    RGSCHCPYTIMEINFO(cell->crntTime, ue->ul.ulTransTime);
9077
9078    /* Allocate UL BSR allocation tracking List */
9079    cmLListInit(&ueUl->ulAllocLst);
9080
9081    for (cnt = 0; cnt < RG_SCH_CMN_MAX_ALLOC_TRACK; cnt++)
9082    {
9083       if((rgSCHUtlAllocSBuf(cell->instIdx,
9084                   (Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
9085       {
9086          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
9087                    "for CRNTI:%d",ueCfg->crnti);
9088          err->errCause = RGSCHERR_SCH_CFG;
9089          RETVALUE(RFAILED);
9090       }
9091       allRcd->allocTime = cell->crntTime;
9092       cmLListAdd2Tail(&ueUl->ulAllocLst, &allRcd->lnk);
9093       allRcd->lnk.node = (PTR)allRcd;
9094    }
9095    /* Allocate common sch cntrl blocks for LCGs */
9096    for (cnt=0; cnt<RGSCH_MAX_LCG_PER_UE; cnt++)
9097    {
9098       ret = rgSCHUtlAllocSBuf(cell->instIdx,
9099             (Data**)&(ue->ul.lcgArr[cnt].sch), (sizeof(RgSchCmnLcg)));
9100       if (ret != ROK)
9101       {
9102          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9103             "SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
9104          err->errCause = RGSCHERR_SCH_CFG;
9105          RETVALUE(ret);
9106       }
9107    }
9108    /* After initialising UL part, do power related init */
9109    ret = rgSCHPwrUeCfg(cell, ue, ueCfg);
9110    if (ret != ROK)
9111    {
9112       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9113          "power config for UE CRNTI:%d",ueCfg->crnti);
9114       RETVALUE(RFAILED);
9115    }
9116 #ifdef LTEMAC_SPS
9117    ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
9118    if (ret != ROK)
9119    {
9120       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
9121          "SPS config for CRNTI:%d",ueCfg->crnti);
9122       RETVALUE(RFAILED);
9123    }
9124 #endif /* LTEMAC_SPS */
9125
9126 #ifdef EMTC_ENABLE   
9127    if(TRUE == ue->isEmtcUe)
9128    {
9129       if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9130       {
9131          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9132                   "for CRNTI:%d",ueCfg->crnti);
9133          RETVALUE(RFAILED);
9134       }
9135    }
9136    else
9137 #endif
9138    {
9139    if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
9140    {
9141       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
9142                "for CRNTI:%d",ueCfg->crnti);
9143       RETVALUE(RFAILED);
9144    }
9145    }
9146
9147    /* DLFS UE Config */
9148    if (cellSchd->dl.isDlFreqSel)
9149    {
9150       if ((cellSchd->apisDlfs->rgSCHDlfsUeCfg(cell, ue, ueCfg, err)) != ROK)
9151       {
9152          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
9153                    "for CRNTI:%d",ueCfg->crnti);
9154          RETVALUE(RFAILED);
9155       }
9156    }
9157
9158    /* Fix: syed align multiple UEs to refresh at same time */
9159    rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9160    /* Start UE Qos Refresh Timer */
9161    rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9162 #ifdef RG_5GTF
9163    rgSCHCmn5gtfUeCfg(cell, ue, ueCfg);
9164 #endif
9165
9166    RETVALUE(ROK);
9167 }  /* rgSCHCmnRgrUeCfg */
9168
9169 /**
9170  * @brief UE TX mode reconfiguration handler.
9171  *
9172  * @details
9173  *
9174  *     Function : rgSCHCmnDlHdlTxModeRecfg
9175  *
9176  *     This functions updates UE specific scheduler
9177  *     information upon UE reconfiguration.
9178  *
9179  *  @param[in]  RgSchUeCb    *ue
9180  *  @param[in] RgrUeRecfg   *ueRecfg
9181  *  @return  Void
9182  **/
9183 #ifdef TFU_UPGRADE
9184 #ifdef ANSI
9185 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9186 (
9187 RgSchCellCb *cell,
9188 RgSchUeCb    *ue,
9189 RgrUeRecfg   *ueRecfg,
9190 U8 numTxPorts
9191 )
9192 #else
9193 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
9194 RgSchCellCb *cell;
9195 RgSchUeCb    *ue;
9196 RgrUeRecfg   *ueRecfg;
9197 U8 numTxPorts;
9198 #endif
9199 #else
9200 #ifdef ANSI
9201 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg
9202 (
9203 RgSchCellCb *cell,
9204 RgSchUeCb    *ue,
9205 RgrUeRecfg   *ueRecfg
9206 )
9207 #else
9208 PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
9209 RgSchCellCb *cell;
9210 RgSchUeCb    *ue;
9211 RgrUeRecfg   *ueRecfg;
9212 #endif
9213 #endif
9214 {
9215    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
9216    TRC2(rgSCHCmnDlHdlTxModeRecfg);
9217
9218    if (ueRecfg->txMode.pres != PRSNT_NODEF)
9219    {
9220       RETVOID;
9221    }
9222    /* ccpu00140894- Starting Timer for TxMode Transition Completion*/
9223    ue->txModeTransCmplt =FALSE;
9224    rgSCHTmrStartTmr (ue->cell, ue, RG_SCH_TMR_TXMODE_TRNSTN, RG_SCH_TXMODE_TRANS_TIMER);
9225    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_CMPLT)
9226    {
9227       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell,
9228                                 RG_SCH_CMN_TD_TXMODE_RECFG);
9229      /* MS_WORKAROUND for ccpu00123186 MIMO Fix Start: need to set FORCE TD bitmap based on TX mode */
9230      ueDl->mimoInfo.ri = 1;
9231      if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9232           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9233       {
9234          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9235       }
9236       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9237       {
9238          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9239       }
9240       /* MIMO Fix End: need to set FORCE TD bitmap based on TX mode */
9241       RETVOID;
9242    }
9243    if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_START)
9244    {
9245       /* start afresh forceTD masking */
9246       RG_SCH_CMN_INIT_FORCE_TD(ue, cell, 0);
9247       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_TXMODE_RECFG);
9248       /* Intialize MIMO related parameters of UE */
9249
9250 #ifdef TFU_UPGRADE
9251       if(ueRecfg->txMode.pres)
9252       {
9253          if((ueRecfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9254                (ueRecfg->txMode.txModeEnum ==RGR_UE_TM_4))
9255          {
9256             if(ueRecfg->ueCodeBookRstRecfg.pres)
9257             {
9258                ueDl->mimoInfo.ri =
9259                   rgSCHCmnComputeRank(ueRecfg->txMode.txModeEnum,
9260                     ueRecfg->ueCodeBookRstRecfg.pmiBitMap, numTxPorts);
9261             }
9262             else
9263             {
9264                ueDl->mimoInfo.ri = 1;
9265             }
9266          }
9267          else
9268          {
9269             ueDl->mimoInfo.ri = 1;
9270          }
9271       }
9272       else
9273       {
9274          ueDl->mimoInfo.ri = 1;
9275       }
9276 #else
9277       ueDl->mimoInfo.ri = 1;
9278 #endif /* TFU_UPGRADE */
9279       if ((ueRecfg->txMode.txModeEnum == RGR_UE_TM_4) ||
9280           (ueRecfg->txMode.txModeEnum == RGR_UE_TM_6))
9281       {
9282          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
9283       }
9284       if (ueRecfg->txMode.txModeEnum == RGR_UE_TM_3)
9285       {
9286          RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
9287       }
9288       RETVOID;
9289    }
9290 }
9291 /***********************************************************
9292  *
9293  *     Func : rgSCHCmnUpdUeMimoInfo
9294  *
9295  *     Desc : Updates UL and DL Ue Information
9296  *
9297  *     Ret  :
9298  *
9299  *     Notes:
9300  *
9301  *     File :
9302  *
9303  **********************************************************/
9304 #ifdef ANSI
9305 PRIVATE Void rgSCHCmnUpdUeMimoInfo
9306 (
9307 RgrUeCfg     *ueCfg,
9308 RgSchCmnDlUe *ueDl,
9309 RgSchCellCb  *cell,
9310 RgSchCmnCell *cellSchd
9311 )
9312 #else
9313 PRIVATE Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
9314 RgrUeCfg     *ueCfg;
9315 RgSchCmnDlUe *ueDl;
9316 RgSchCellCb  *cell;
9317 RgSchCmnCell *cellSchd;
9318 #endif
9319 {
9320    TRC2(rgSCHCmnUpdUeMimoInfo)
9321 #ifdef TFU_UPGRADE
9322    if(ueCfg->txMode.pres)
9323    {
9324       if((ueCfg->txMode.txModeEnum ==RGR_UE_TM_3) ||
9325             (ueCfg->txMode.txModeEnum ==RGR_UE_TM_4))
9326       {
9327          if(ueCfg->ueCodeBookRstCfg.pres)
9328          {
9329             ueDl->mimoInfo.ri =
9330                rgSCHCmnComputeRank(ueCfg->txMode.txModeEnum,
9331                  ueCfg->ueCodeBookRstCfg.pmiBitMap, cell->numTxAntPorts);
9332          }
9333          else
9334          {
9335             ueDl->mimoInfo.ri = 1;
9336          }
9337       }
9338       else
9339       {
9340          ueDl->mimoInfo.ri = 1;
9341       }
9342    }
9343    else
9344    {
9345       ueDl->mimoInfo.ri = 1;
9346    }
9347
9348 #else
9349    ueDl->mimoInfo.ri = 1;
9350 #endif /*TFU_UPGRADE */
9351    ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
9352    ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
9353
9354    RETVOID;
9355 }
9356 /***********************************************************
9357  *
9358  *     Func : rgSCHCmnUpdUeUlCqiInfo
9359  *
9360  *     Desc : Updates UL and DL Ue Information
9361  *
9362  *     Ret  :
9363  *
9364  *     Notes:
9365  *
9366  *     File :
9367  *
9368  **********************************************************/
9369 #ifdef ANSI
9370 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo
9371 (
9372 RgSchCellCb   *cell,
9373 RgSchUeCb     *ue,
9374 RgSchCmnUlUe  *ueUl,
9375 RgSchCmnUe    *ueSchCmn,
9376 RgSchCmnCell  *cellSchd,
9377 Bool          isEcp
9378 )
9379 #else
9380 PRIVATE Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
9381 RgSchCellCb  *cell;
9382 RgSchUeCb    *ue;
9383 RgSchCmnUlUe *ueUl;
9384 RgSchCmnUe   *ueSchCmn;
9385 RgSchCmnCell *cellSchd;
9386 Bool          isEcp;
9387 #endif
9388 {
9389
9390    TRC2(rgSCHCmnUpdUeUlCqiInfo)
9391
9392 #ifdef TFU_UPGRADE
9393    if(ue->srsCb.srsCfg.type  ==  RGR_SCH_SRS_SETUP)
9394    {
9395      if(ue->ul.ulTxAntSel.pres)
9396      {
9397        ueUl->crntUlCqi[ue->srsCb.selectedAnt] = cellSchd->ul.dfltUlCqi;
9398        ueUl->validUlCqi = ueUl->crntUlCqi[ue->srsCb.selectedAnt];
9399      }
9400      else
9401      {
9402        ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9403        ueUl->validUlCqi =  ueUl->crntUlCqi[0];
9404      }
9405       ue->validTxAnt = ue->srsCb.selectedAnt;
9406    }
9407    else
9408    {
9409       ueUl->validUlCqi = cellSchd->ul.dfltUlCqi;
9410       ue->validTxAnt = 0;
9411    }
9412 #ifdef UL_LA
9413    ueUl->ulLaCb.cqiBasediTbs = rgSchCmnUlCqiToTbsTbl[isEcp]
9414                                                 [ueUl->validUlCqi] * 100;   
9415    ueUl->ulLaCb.deltaiTbs = 0;
9416 #endif
9417
9418 #else
9419    ueUl->crntUlCqi[0] = cellSchd->ul.dfltUlCqi;
9420 #endif /*TFU_UPGRADE */
9421    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
9422    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9423    {
9424       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9425    }
9426    else
9427    {
9428       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9429    }
9430
9431    RETVOID;
9432 }
9433 /***********************************************************
9434  *
9435  *     Func : rgSCHCmnUpdUeCatCfg
9436  *
9437  *     Desc : Updates UL and DL Ue Information
9438  *
9439  *     Ret  :
9440  *
9441  *     Notes:
9442  *
9443  *     File :
9444  *
9445  **********************************************************/
9446 #ifdef ANSI
9447 PRIVATE Void rgSCHCmnUpdUeCatCfg
9448 (
9449 RgSchUeCb    *ue,
9450 RgSchCellCb  *cell
9451 )
9452 #else
9453 PRIVATE Void rgSCHCmnUpdUeCatCfg(ue, cell)
9454 RgSchUeCb    *ue;
9455 RgSchCellCb  *cell;
9456 #endif
9457 {
9458    RgSchDlHqEnt *hqE = NULLP;
9459    RgSchCmnUlUe *ueUl     = RG_SCH_CMN_GET_UL_UE(ue,cell);
9460    RgSchCmnDlUe *ueDl     = RG_SCH_CMN_GET_DL_UE(ue,cell);
9461    RgSchCmnUe   *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
9462    RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
9463
9464    TRC2(rgSCHCmnUpdUeCatCfg)
9465
9466    ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
9467    
9468    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9469    /*CA dev-Start*/
9470    U8 ri = 0;
9471    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
9472    if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
9473             ||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat)) 
9474          && (RG_SCH_MAX_TX_LYRS_4 == ri))
9475    {
9476       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[1];
9477    }
9478    else
9479    {
9480       ueDl->maxTbSz = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlBits[0];
9481    }
9482    /*CA dev-End*/
9483    ueDl->maxSbSz = (rgUeCatTbl[ueSchCmn->cmn.ueCat].maxSftChBits/
9484                            hqE->numHqPrcs);
9485    if (rgUeCatTbl[ueSchCmn->cmn.ueCat].ul64qamSup == FALSE)
9486    {
9487       ueUl->maxUlCqi = cellSchd->ul.max16qamCqi;
9488    }
9489    else
9490    {
9491       ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
9492    }
9493    ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
9494                    RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
9495    RETVOID;
9496 }
9497
9498 /**
9499  * @brief UE reconfiguration for scheduler.
9500  *
9501  * @details
9502  *
9503  *     Function : rgSChCmnRgrUeRecfg
9504  *
9505  *     This functions updates UE specific scheduler
9506  *     information upon UE reconfiguration.
9507  *
9508  *  @param[in]  RgSchCellCb  *cell
9509  *  @param[in]  RgSchUeCb    *ue
9510  *  @param[int] RgrUeRecfg   *ueRecfg
9511  *  @param[out] RgSchErrInfo *err
9512  *  @return  S16
9513  *      -# ROK
9514  *      -# RFAILED
9515  **/
9516 #ifdef ANSI
9517 PUBLIC S16 rgSCHCmnRgrUeRecfg
9518 (
9519 RgSchCellCb  *cell,
9520 RgSchUeCb    *ue,
9521 RgrUeRecfg   *ueRecfg,
9522 RgSchErrInfo *err
9523 )
9524 #else
9525 PUBLIC S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
9526 RgSchCellCb  *cell;
9527 RgSchUeCb    *ue;
9528 RgrUeRecfg   *ueRecfg;
9529 RgSchErrInfo *err;
9530 #endif
9531 {
9532    RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9533    U32          waitPer;
9534
9535    TRC2(rgSCHCmnRgrUeRecfg);
9536    /* Basic validations */
9537    if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
9538    {
9539 #ifdef TFU_UPGRADE
9540       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, cell->numTxAntPorts);
9541 #else
9542       rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg);
9543 #endif /* TFU_UPGRADE */
9544    }
9545    if(ueRecfg->ueRecfgTypes & RGR_UE_CSG_PARAM_RECFG)
9546    {
9547       ue->csgMmbrSta = ueRecfg->csgMmbrSta;
9548    }
9549    /* Changes for UE Category reconfiguration feature */
9550    if(ueRecfg->ueRecfgTypes & RGR_UE_UECAT_RECFG)
9551    {
9552        rgSCHCmnUpdUeCatCfg(ue, cell);
9553    }
9554    if (ueRecfg->ueRecfgTypes & RGR_UE_APRD_DLCQI_RECFG)
9555    {
9556       RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
9557       pCellInfo->acqiCb.aCqiCfg = ueRecfg->aprdDlCqiRecfg;
9558    }
9559 #ifndef TFU_UPGRADE
9560    if (ueRecfg->ueRecfgTypes & RGR_UE_PRD_DLCQI_RECFG)
9561    {
9562       if ((ueRecfg->prdDlCqiRecfg.pres == TRUE)
9563             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD10)
9564             && (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD20))
9565       {
9566          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unsupported periodic CQI "
9567             "reporting mode %d for old CRNIT:%d", 
9568             (int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
9569          err->errCause = RGSCHERR_SCH_CFG;
9570          RETVALUE(RFAILED);
9571       }
9572      ue->dl.ueDlCqiCfg.prdCqiCfg = ueRecfg->prdDlCqiRecfg;
9573    }
9574 #endif
9575
9576    if (ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG)
9577    {
9578       if (rgSCHPwrUeRecfg(cell, ue, ueRecfg) != ROK)
9579       {
9580          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
9581                "Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
9582          RETVALUE(RFAILED);
9583       }
9584    }
9585
9586    if (ueRecfg->ueRecfgTypes & RGR_UE_QOS_RECFG)
9587    {
9588       /* Uplink Sched related Initialization */
9589       if ((ueRecfg->ueQosRecfg.dlAmbr == 0) && (ueRecfg->ueQosRecfg.ueBr == 0))
9590       {
9591          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
9592             "configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
9593          err->errCause = RGSCHERR_SCH_CFG;
9594          RETVALUE(RFAILED);
9595       }
9596       ue->ul.cfgdAmbr = (ueRecfg->ueQosRecfg.ueBr * \
9597       RG_SCH_CMN_REFRESH_TIME)/100;
9598       /* Downlink Sched related Initialization */
9599       ue->dl.ambrCfgd = (ueRecfg->ueQosRecfg.dlAmbr * \
9600       RG_SCH_CMN_REFRESH_TIME)/100;
9601       /* Fix: syed Update the effAmbr and effUeBR fields w.r.t the
9602        * new QOS configuration */
9603       rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9604       /* Fix: syed align multiple UEs to refresh at same time */
9605       rgSCHCmnGetRefreshPer(cell, ue, &waitPer);
9606       rgSCHCmnApplyUeRefresh(cell, ue);
9607       rgSCHCmnAddUeToRefreshQ(cell, ue, waitPer);
9608    }
9609 #ifdef EMTC_ENABLE   
9610    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9611    {
9612       if ((cellSchCmn->apisEmtcUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9613       {
9614          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9615                "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9616          RETVALUE(RFAILED);
9617       }
9618       if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9619       {
9620          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9621                "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9622          RETVALUE(RFAILED);
9623       }
9624    }
9625    else
9626 #endif
9627    {
9628       if ((cellSchCmn->apisUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9629       {
9630          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9631             "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9632          RETVALUE(RFAILED);
9633       }
9634       if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
9635       {
9636          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9637             "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
9638          RETVALUE(RFAILED);
9639       }
9640    }
9641    /* DLFS UE Config */
9642    if (cellSchCmn->dl.isDlFreqSel)
9643    {
9644       if ((cellSchCmn->apisDlfs->rgSCHDlfsUeRecfg(cell, ue, \
9645          ueRecfg, err)) != ROK)
9646       {
9647          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9648                "DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
9649          RETVALUE(RFAILED);
9650       }
9651    }
9652
9653 #ifdef LTEMAC_SPS
9654    /* Invoke re-configuration on SPS module */
9655    if (rgSCHCmnSpsUeRecfg(cell, ue, ueRecfg, err) != ROK)
9656    {
9657       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
9658               "DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
9659       RETVALUE(RFAILED);
9660    }
9661 #endif
9662
9663    RETVALUE(ROK);
9664 }  /* rgSCHCmnRgrUeRecfg*/
9665
9666 /***********************************************************
9667  *
9668  *     Func : rgSCHCmnUlUeDelAllocs
9669  *
9670  *     Desc : Deletion of all UE allocations.
9671  *
9672  *     Ret  :
9673  *
9674  *     Notes:
9675  *
9676  *     File :
9677  *
9678  **********************************************************/
9679 #ifdef ANSI
9680 PRIVATE Void rgSCHCmnUlUeDelAllocs
9681 (
9682 RgSchCellCb  *cell,
9683 RgSchUeCb   *ue
9684 )
9685 #else
9686 PRIVATE Void rgSCHCmnUlUeDelAllocs(cell, ue)
9687 RgSchCellCb  *cell;
9688 RgSchUeCb   *ue;
9689 #endif
9690 {
9691    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
9692    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
9693    U8 i;
9694 #ifdef LTEMAC_SPS
9695    RgSchCmnUlUeSpsInfo   *ulSpsUe   = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
9696 #endif
9697    TRC2(rgSCHCmnUlUeDelAllocs);
9698
9699    for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
9700    {
9701       RgSchUlHqProcCb *proc = rgSCHUhmGetUlHqProc(cell, ue, i);
9702
9703 #ifdef ERRCLS_KW
9704       /* proc can't be NULL here */
9705       if (proc)
9706 #endif
9707       {
9708          /* R8 Upgrade */
9709          proc->ndi = 0;
9710          if (proc->alloc)
9711          {
9712             /* Added Insure Fixes Of reading Dangling memory.NULLed crntAlloc */
9713 #ifdef LTEMAC_SPS
9714             if(proc->alloc == ulSpsUe->ulSpsSchdInfo.crntAlloc)
9715             {
9716                ulSpsUe->ulSpsSchdInfo.crntAlloc = NULLP;
9717                ulSpsUe->ulSpsSchdInfo.crntAllocSf = NULLP;
9718             }
9719 #endif
9720 #ifdef EMTC_ENABLE
9721             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9722                   proc->alloc,ue->isEmtcUe);
9723 #else
9724             rgSCHCmnUlFreeAllocation(cell, &cellUl->ulSfArr[proc->ulSfIdx],
9725                   proc->alloc);
9726 #endif
9727             /* PHY probably needn't be intimated since
9728              * whatever intimation it needs happens at the last minute
9729              */
9730          }
9731          /* Fix: syed Adaptive Msg3 Retx crash. Remove the harqProc
9732           * from adaptive retx List. */
9733          if (proc->reTxLnk.node)
9734          {
9735             {
9736                //TODO_SID: Need to take care
9737                cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk); 
9738                proc->reTxLnk.node = (PTR)NULLP;
9739             }
9740          }
9741       }
9742    }
9743    RETVOID;
9744 }
9745
9746 /***********************************************************
9747  *
9748  *     Func : rgSCHCmnDelUeFrmRefreshQ
9749  *
9750  *     Desc : Adds a UE to refresh queue, so that the UE is
9751  *            periodically triggered to refresh it's GBR and
9752  *            AMBR values.
9753  *
9754  *     Ret  :
9755  *
9756  *     Notes:
9757  *
9758  *     File :
9759  *
9760  **********************************************************/
9761 #ifdef ANSI
9762 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ
9763 (
9764 RgSchCellCb     *cell,
9765 RgSchUeCb       *ue
9766 )
9767 #else
9768 PRIVATE Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
9769 RgSchCellCb     *cell;
9770 RgSchUeCb       *ue;
9771 #endif
9772 {
9773    RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
9774    CmTmrArg       arg;
9775    RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
9776
9777    TRC2(rgSCHCmnDelUeFrmRefreshQ);
9778
9779 #ifdef RGL_SPECIFIC_CHANGES
9780    if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
9781    {
9782       if(cell->refreshUeCnt[ue->refreshOffset])
9783       {
9784          cell->refreshUeCnt[ue->refreshOffset]--;
9785       }
9786    }
9787 #endif
9788
9789
9790    cmMemset((U8 *)&arg, 0, sizeof(arg));
9791    arg.tqCp   = &sched->tmrTqCp;
9792    arg.tq     = sched->tmrTq;
9793    arg.timers = &ueSchd->tmr;
9794    arg.cb     = (PTR)ue;
9795    arg.tNum   = 0;
9796    arg.max    = 1;
9797    arg.evnt   = RG_SCH_CMN_EVNT_UE_REFRESH;
9798
9799    cmRmvCbTq(&arg);
9800    RETVOID;
9801 }
9802
9803 /***********************************************************
9804  *
9805  *     Func : rgSCHCmnUeCcchSduDel
9806  *
9807  *     Desc : Clear CCCH SDU scheduling context.
9808  *
9809  *     Ret  :
9810  *
9811  *     Notes:
9812  *
9813  *     File :
9814  *
9815  **********************************************************/
9816 #ifdef ANSI
9817 PRIVATE Void rgSCHCmnUeCcchSduDel
9818 (
9819 RgSchCellCb  *cell,
9820 RgSchUeCb    *ueCb
9821 )
9822 #else
9823 PRIVATE Void rgSCHCmnUeCcchSduDel(cell, ueCb)
9824 RgSchCellCb  *cell;
9825 RgSchUeCb    *ueCb;
9826 #endif
9827 {
9828    RgSchDlHqEnt      *hqE = NULLP;
9829    RgSchDlHqProcCb   *ccchSduHqP = NULLP;
9830    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
9831
9832    TRC2(rgSCHCmnUeCcchSduDel);
9833
9834    hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
9835    if (hqE == NULLP)
9836    {
9837       RETVOID;
9838    }
9839    ccchSduHqP = hqE->ccchSduProc;
9840    if(ueCb->ccchSduLnk.node != NULLP)
9841    {
9842       /* Remove the ccchSduProc if it is in the Tx list */
9843       cmLListDelFrm(&(cell->ccchSduUeLst), &(ueCb->ccchSduLnk));
9844       ueCb->ccchSduLnk.node = NULLP;   
9845    }
9846    else if(ccchSduHqP != NULLP)
9847    {
9848       /* Fix for crash due to stale pdcch. Release ccch pdcch*/
9849       if(ccchSduHqP->pdcch)
9850       {
9851          cmLListDelFrm(&ccchSduHqP->subFrm->pdcchInfo.pdcchs,
9852                &ccchSduHqP->pdcch->lnk);
9853          cmLListAdd2Tail(&cell->pdcchLst, &ccchSduHqP->pdcch->lnk);
9854          ccchSduHqP->pdcch = NULLP;
9855       }
9856       if(ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node != NULLP)
9857       {
9858          /* Remove the ccchSduProc if it is in the retx list */
9859          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
9860           &ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk);
9861          /* ccchSduHqP->tbInfo[0].ccchSchdInfo.retxLnk.node = NULLP; */
9862          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9863       }
9864       else if ((ccchSduHqP->subFrm != NULLP) &&
9865        (ccchSduHqP->hqPSfLnk.node != NULLP))
9866       {
9867          rgSCHUtlDlHqPTbRmvFrmTx(ccchSduHqP->subFrm, 
9868                ccchSduHqP, 0, FALSE);
9869          rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
9870       }
9871    }   
9872    RETVOID;
9873 }
9874
9875
9876
9877
9878 /**
9879  * @brief UE deletion for scheduler.
9880  *
9881  * @details
9882  *
9883  *     Function : rgSCHCmnUeDel
9884  *
9885  *     This functions deletes all scheduler information
9886  *     pertaining to an UE.
9887  *
9888  *  @param[in]  RgSchCellCb  *cell
9889  *  @param[in]  RgSchUeCb    *ue
9890  *  @return  Void
9891  **/
9892 #ifdef ANSI
9893 PUBLIC Void rgSCHCmnUeDel
9894 (
9895 RgSchCellCb  *cell,
9896 RgSchUeCb    *ue
9897 )
9898 #else
9899 PUBLIC Void rgSCHCmnUeDel(cell, ue)
9900 RgSchCellCb  *cell;
9901 RgSchUeCb    *ue;
9902 #endif
9903 {
9904    RgSchDlHqEnt         *hqE = NULLP;
9905    RgSchCmnUlUe         *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
9906    CmLList              *node;
9907    RgSchCmnAllocRecord  *allRcd;
9908    U8                    cnt;
9909    RgSchCmnCell         *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
9910    U32                   idx = 0;
9911    TRC2(rgSCHCmnUeDel);
9912
9913    if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
9914    {
9915       /* Common scheduler config has not happened yet */
9916       RETVOID;
9917    }
9918    hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
9919    if(hqE)
9920    {
9921       /* UE Free can be triggered before MSG4 done when dlHqE is not updated */
9922 #ifdef EMTC_ENABLE
9923       if(ue->isEmtcUe)
9924       {
9925          rgSCHEmtcCmnUeCcchSduDel(cell, ue);
9926       }
9927       else
9928 #endif
9929      {    
9930          rgSCHCmnUeCcchSduDel(cell, ue);
9931      }
9932    }
9933    rgSCHCmnDelUeFrmRefreshQ(cell, ue);
9934
9935    rgSCHCmnUlUeDelAllocs(cell, ue);
9936
9937    rgSCHCmnDelRachInfo(cell, ue);
9938
9939 #ifdef EMTC_ENABLE   
9940    if(TRUE == ue->isEmtcUe)
9941    {
9942       cellSchCmn->apisEmtcUl->rgSCHFreeUlUe(cell, ue);
9943    }
9944    else
9945 #endif
9946    {
9947    cellSchCmn->apisUl->rgSCHFreeUlUe(cell, ue);
9948    }
9949 #ifdef LTE_ADV
9950    if (ue->numSCells)
9951    {
9952       for(idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
9953       {
9954          if(ue->cellInfo[idx] != NULLP) 
9955          {
9956             rgSCHSCellDelUeSCell(cell,ue,idx);
9957          }
9958       }
9959
9960    }
9961 #endif
9962 #ifdef EMTC_ENABLE
9963    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
9964    {
9965       cellSchCmn->apisEmtcDl->rgSCHFreeDlUe(cell, ue);
9966    }
9967    else
9968 #endif
9969    {
9970       cellSchCmn->apisDl->rgSCHFreeDlUe(cell, ue);
9971    }
9972    rgSCHPwrUeDel(cell, ue);
9973
9974 #ifdef LTEMAC_SPS
9975    rgSCHCmnSpsUeDel(cell, ue);
9976 #endif /* LTEMAC_SPS*/
9977
9978    /* CA Dev Start*/
9979    rgSchCmnDlSfHqDel(ue, cell);
9980    /* CA Dev End*/
9981    /* DLFS UE delete */
9982    if (cellSchCmn->dl.isDlFreqSel)
9983    {
9984       cellSchCmn->apisDlfs->rgSCHDlfsUeDel(cell, ue);
9985    }
9986    node = ueUl->ulAllocLst.first;
9987
9988 /* ccpu00117052 - MOD - Passing double pointer in all the places of
9989    rgSCHUtlFreeSBuf function call for proper NULLP assignment*/
9990    while(node)
9991    {
9992       allRcd = (RgSchCmnAllocRecord *)node->node;
9993       node = node->next;
9994       cmLListDelFrm(&ueUl->ulAllocLst, &allRcd->lnk);
9995       rgSCHUtlFreeSBuf(cell->instIdx,
9996          (Data**)(&allRcd), (sizeof(RgSchCmnAllocRecord)));
9997    }
9998
9999    for(cnt = 0; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
10000    {
10001       if (ue->ul.lcgArr[cnt].sch != NULLP)
10002       {
10003          rgSCHUtlFreeSBuf(cell->instIdx,
10004             (Data**)(&(ue->ul.lcgArr[cnt].sch)), (sizeof(RgSchCmnLcg)));
10005       }
10006    }
10007
10008    /* Fix : syed Moved hqEnt deinit to rgSCHCmnDlDeInitHqEnt */
10009    idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
10010    rgSCHUtlFreeSBuf(cell->instIdx,
10011          (Data**)(&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch))), (sizeof(RgSchCmnUe)));
10012    RETVOID;
10013 }  /* rgSCHCmnUeDel */
10014
10015 \f
10016 /**
10017  * @brief This function handles the common code rate configurations
10018  *        done as part of RgrCellCfg/RgrCellRecfg.
10019  *
10020  * @details
10021  *
10022  *     Function: rgSCHCmnDlCnsdrCmnRt
10023  *     Purpose:  This function handles the common code rate configurations
10024  *        done as part of RgrCellCfg/RgrCellRecfg.
10025  *
10026  *     Invoked by: Scheduler
10027  *
10028  *  @param[in]  RgSchCellCb                *cell
10029  *  @param[in]  RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10030  *  @return     S16
10031  *
10032  **/
10033 #ifdef ANSI
10034 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt
10035 (
10036 RgSchCellCb             *cell,
10037 RgrDlCmnCodeRateCfg     *dlCmnCodeRate
10038 )
10039 #else
10040 PRIVATE S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
10041 RgSchCellCb             *cell;
10042 RgrDlCmnCodeRateCfg     *dlCmnCodeRate;
10043 #endif
10044 {
10045    RgSchCmnCell         *cellDl = RG_SCH_CMN_GET_CELL(cell);
10046    U32                  bitsPerRb;
10047    U32                  bitsPer2Rb;
10048    U32                  bitsPer3Rb;
10049    U8                   i, rbNum;
10050    U32                  pdcchBits;
10051
10052    TRC2(rgSCHCmnDlCnsdrCmnRt);
10053
10054    /* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
10055     * bits per 1024/2 REs */
10056    if (dlCmnCodeRate->bcchPchRaCodeRate != 0)
10057    {
10058       bitsPerRb = ((dlCmnCodeRate->bcchPchRaCodeRate * 2) *
10059             cellDl->dl.noResPerRb[3])/1024;
10060    }
10061    else
10062    {
10063       bitsPerRb = ((RG_SCH_CMN_DEF_BCCHPCCH_CODERATE * 2) *
10064             cellDl->dl.noResPerRb[3])/1024;
10065    }
10066    /* Store bitsPerRb in cellDl->dl to use later to determine
10067     * Number of RBs for UEs with SI-RNTI, P-RNTI and RA-RNTI */
10068    cellDl->dl.bitsPerRb = bitsPerRb;
10069    /* ccpu00115595 end*/
10070    /* calculate the ITbs for 2 RBs. Initialize ITbs to MAX value */
10071    i = 0;
10072    rbNum = 2;
10073    bitsPer2Rb = bitsPerRb * rbNum;
10074    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer2Rb))
10075       i++;
10076
10077    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs2Rbs = 0) :
10078       (cellDl->dl.cmnChITbs.iTbs2Rbs = i-1);
10079
10080    /* calculate the ITbs for 3 RBs. Initialize ITbs to MAX value */
10081    i = 0;
10082    rbNum = 3;
10083    bitsPer3Rb = bitsPerRb * rbNum;
10084    while ((i < 9) && (rgTbSzTbl[0][i][rbNum - 1] <= bitsPer3Rb))
10085          i++;
10086
10087    (i <= 1)? (cellDl->dl.cmnChITbs.iTbs3Rbs = 0) :
10088       (cellDl->dl.cmnChITbs.iTbs3Rbs = i-1);
10089
10090
10091    pdcchBits = 1 + /* Flag for format0/format1a differentiation */
10092       1 + /* Localized/distributed VRB assignment flag */
10093       5 + /* For mcs */
10094 #ifndef LTE_TDD
10095       3 + /* Harq process Id */
10096 #else
10097       4 + /* Harq process Id */
10098       2 + /* UL Index or DAI */
10099 #endif
10100       1 + /* New Data Indicator */
10101       2 + /* For RV */
10102       2 + /* For tpc */
10103       1 + rgSCHUtlLog32bitNbase2((cell->bwCfg.dlTotalBw * \
10104                (cell->bwCfg.dlTotalBw + 1))/2);
10105    /* Resource block assignment ceil[log2(bw(bw+1)/2)] : \
10106       Since VRB is local */
10107    /* For TDD consider DAI */
10108
10109    /* Convert the pdcchBits to actual pdcchBits required for transmission */
10110    if (dlCmnCodeRate->pdcchCodeRate != 0)
10111    {
10112       pdcchBits = (pdcchBits * 1024)/dlCmnCodeRate->pdcchCodeRate;
10113       if (pdcchBits <= 288) /* 288 : Num of pdcch bits for aggrLvl=4 */
10114       {
10115          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10116       }
10117       else                  /* 576 : Num of pdcch bits for aggrLvl=8 */
10118       {
10119          cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL8;
10120       }
10121    }
10122    else
10123    {
10124       cellDl->dl.cmnChAggrLvl = CM_LTE_AGGR_LVL4;
10125    }
10126    if (dlCmnCodeRate->ccchCqi == 0)
10127    {
10128       RETVALUE(RFAILED);
10129    }
10130    else
10131    {
10132       cellDl->dl.ccchCqi = dlCmnCodeRate->ccchCqi;
10133    }
10134    RETVALUE(ROK);
10135 }
10136
10137 #ifdef LTE_TDD
10138 /**
10139  * @brief This function handles the configuration of cell for the first
10140  *        time by the scheduler.
10141  *
10142  * @details
10143  *
10144  *     Function: rgSCHCmnDlRgrCellCfg
10145  *     Purpose:  Configuration received is stored into the data structures
10146  *               Also, update the scheduler with the number of frames of
10147  *               RACH preamble transmission.
10148  *
10149  *     Invoked by: BO and Scheduler
10150  *
10151  *  @param[in]  RgSchCellCb*     cell
10152  *  @param[in]  RgrCellCfg*      cfg
10153  *  @return     S16
10154  *
10155  **/
10156 #ifdef ANSI
10157 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10158 (
10159 RgSchCellCb    *cell,
10160 RgrCellCfg     *cfg,
10161 RgSchErrInfo   *err
10162 )
10163 #else
10164 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10165 RgSchCellCb    *cell;
10166 RgrCellCfg     *cfg;
10167 RgSchErrInfo   *err;
10168 #endif
10169 {
10170    RgSchCmnCell         *cellSch;
10171    U8                   cp;
10172    U8                   sfCount;
10173    U8                   numPdcchSym;
10174    U8                   noSymPerSlot;
10175    U8                   maxDlSubfrms = cell->numDlSubfrms;
10176    U8                   splSubfrmIdx = cfg->spclSfCfgIdx;
10177    U8                   swPtCnt = 0;
10178    Bool                 isSplfrm;
10179    RgSchTddSubfrmInfo   subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
10180    S16                  ret;
10181    U8                   splSfIdx;
10182    U8                   antPortIdx;
10183    U8                   numCrs;
10184    U8                   cfi;  
10185    U8                   cfiIdx;
10186    RgSchDlSf            *sf;
10187    U8                   splSfCfi;
10188    U8                   mPhich;
10189
10190    TRC2(rgSCHCmnDlRgrCellCfg);
10191    
10192
10193    cellSch = RG_SCH_CMN_GET_CELL(cell);
10194    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->\
10195                                                   rachCfg.preambleFormat];
10196    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10197    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10198    
10199    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10200                        3 TTI (MAX L1+L2 processing delay at the UE) */
10201    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10202                                  rgSchCmnHarqRtt[cell->ulDlCfgIdx] + 3; 
10203    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10204    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10205    if (cfg->maxUePerDlSf == 0)
10206    {
10207       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10208    }
10209    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10210    {
10211       RETVALUE(RFAILED);
10212    }
10213
10214
10215    if (cell->bwCfg.dlTotalBw <= 10)
10216    {
10217       cfiIdx = 1;
10218       numPdcchSym = 2;
10219    }
10220    else
10221    {
10222       cfiIdx = 0;
10223       numPdcchSym = 1;
10224    }
10225    /* DwPTS Scheduling Changes Start */
10226    cellSch->dl.splSfCfg  = splSubfrmIdx;
10227  
10228    if (cfg->isCpDlExtend == TRUE)
10229    {
10230       if((0 == splSubfrmIdx) || (4 == splSubfrmIdx) ||
10231          (7 == splSubfrmIdx) || (8 == splSubfrmIdx)
10232         )
10233       {
10234          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10235       }
10236       else
10237       {
10238          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10239       }
10240    }
10241    else
10242    {
10243       /* Refer to 36.213 Section 7.1.7 */
10244       if((0 == splSubfrmIdx) || (5 == splSubfrmIdx))
10245       {
10246          cell->splSubfrmCfg.isDlDataAllowed = FALSE; 
10247       }
10248       else
10249       {
10250          cell->splSubfrmCfg.isDlDataAllowed = TRUE; 
10251       }
10252    }
10253    /* DwPTS Scheduling Changes End */  
10254
10255    splSfCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10256    RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
10257    
10258    for (sfCount = 0; sfCount < maxDlSubfrms; sfCount++)
10259    {
10260       sf = cell->subFrms[sfCount];
10261       /* Sfcount matches the first special subframe occurs at Index 0
10262             * or subsequent special subframes */
10263       if(subfrmInfo.switchPoints == 1)
10264       {
10265          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10266                                  RG_SCH_CMN_10_MS_PRD, &subfrmInfo);
10267       }
10268       else
10269       {
10270          isSplfrm = rgSCHCmnIsSplSubfrm(swPtCnt, sfCount,
10271                                  RG_SCH_CMN_5_MS_PRD, &subfrmInfo);
10272       }
10273       if(isSplfrm == TRUE)
10274       {
10275          swPtCnt++;
10276          /* DwPTS Scheduling Changes Start */        
10277          if (cell->splSubfrmCfg.isDlDataAllowed == TRUE)
10278          {
10279             sf->sfType = RG_SCH_SPL_SF_DATA;
10280          }
10281          else
10282          {
10283             sf->sfType = RG_SCH_SPL_SF_NO_DATA;
10284          }
10285          /* DwPTS Scheduling Changes End */
10286       }
10287       else
10288       {
10289          /* DwPTS Scheduling Changes Start */
10290          if (sf->sfNum != 0)
10291          {
10292             sf->sfType = RG_SCH_DL_SF;
10293          }
10294          else
10295          {
10296             sf->sfType = RG_SCH_DL_SF_0;
10297          }
10298          /* DwPTS Scheduling Changes End */
10299       }
10300       
10301       /* Calculate the number of CCEs per subframe in the cell */
10302       mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][sf->sfNum];
10303       if(cell->dynCfiCb.isDynCfiEnb == TRUE)
10304       {   
10305          /* In case if Dynamic CFI feature is enabled, default CFI 
10306           * value 1 is used  */
10307          sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][1];
10308       }
10309       else
10310       {
10311          if (sf->sfType == RG_SCH_SPL_SF_DATA)
10312          {
10313             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
10314          }
10315          else
10316          {
10317             sf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi)];
10318          }
10319       }   
10320    }
10321
10322    /* Intialize the RACH response scheduling related infromation */
10323    if(rgSCHCmnDlRachInfoInit(cell) != ROK)
10324    {
10325      RETVALUE(RFAILED);
10326    }
10327
10328    /* Allocate PRACH preamble list */
10329    rgSCHCmnDlCreateRachPrmLst(cell);
10330
10331    /* Initialize PHICH offset information */
10332    rgSCHCmnDlPhichOffsetInit(cell);
10333
10334    /* Update the size of HARQ ACK/NACK feedback table */
10335    /* The array size is increased by 2 to have enough free indices, where other
10336     * indices are busy waiting for HARQ feedback */
10337    cell->ackNackFdbkArrSize = rgSchTddANFdbkMapTbl[cell->ulDlCfgIdx] + 2; 
10338
10339    /* Initialize expected HARQ ACK/NACK feedback time */
10340    rgSCHCmnDlANFdbkInit(cell);
10341
10342    /* Initialize UL association set index */
10343    if(cell->ulDlCfgIdx != 0)
10344    {
10345       rgSCHCmnDlKdashUlAscInit(cell);
10346    }
10347
10348    if (cfg->isCpDlExtend == TRUE)
10349    {
10350       cp = RG_SCH_CMN_EXT_CP;
10351       noSymPerSlot = 6;
10352       cell->splSubfrmCfg.dwPts =
10353           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlDwPts;
10354    
10355       if ( cell->splSubfrmCfg.dwPts == 0 )
10356       {
10357          cell->isDwPtsCnted = FALSE;
10358       }
10359       else
10360       {
10361          cell->isDwPtsCnted = TRUE;
10362       }
10363
10364       if(cfg->isCpUlExtend == TRUE)
10365       {
10366          cell->splSubfrmCfg.upPts =
10367             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlExtUpPts;
10368       }
10369       else
10370       {
10371          cell->splSubfrmCfg.upPts =
10372             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].extDlNorUpPts;
10373       }
10374    }
10375    else
10376    {
10377       cp = RG_SCH_CMN_NOR_CP;
10378       noSymPerSlot = 7;
10379       cell->splSubfrmCfg.dwPts =
10380           rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlDwPts;
10381       cell->isDwPtsCnted = TRUE;
10382
10383       if(cfg->isCpUlExtend == TRUE)
10384       {
10385          cell->splSubfrmCfg.upPts =
10386             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlExtUpPts;
10387       }
10388       else
10389       {
10390          cell->splSubfrmCfg.upPts =
10391             rgSchTddSplSubfrmInfoTbl[splSubfrmIdx].norDlNorUpPts;
10392       }
10393    }
10394
10395    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10396    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++,cfiIdx++)
10397    {   
10398       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10399       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10400                                                  [cell->numTxAntPorts]][cfiIdx];
10401       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10402       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10403                                                  [cell->numTxAntPorts]][cfiIdx];
10404    }
10405
10406    /* Initializing the values of CFI parameters */
10407    if(cell->dynCfiCb.isDynCfiEnb)
10408    {   
10409       /* If DCFI is enabled, current CFI value will start from 1 */
10410       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10411    }
10412    else
10413    {
10414       /* If DCFI is disabled, current CFI value is set as default max allowed CFI value */
10415       cellSch->dl.currCfi = RGSCH_MIN(cell->dynCfiCb.maxCfi, cellSch->cfiCfg.cfi);
10416       cellSch->dl.newCfi = cellSch->dl.currCfi;
10417    }   
10418
10419    /* Include CRS REs while calculating Efficiency
10420     * The number of Resource Elements occupied by CRS depends on Number of
10421     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10422     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10423     * details of the same. Please note that PDCCH overlap symbols would not
10424     * considered in CRS REs deduction */
10425    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10426    {
10427       cellSch->dl.noResPerRb[cfi] = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10428             - numPdcchSym) *RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10429    }
10430
10431    /* DwPTS Scheduling Changes Start */
10432    antPortIdx = (cell->numTxAntPorts == 1)? 0: 
10433       ((cell->numTxAntPorts == 2)? 1: 2);     
10434
10435    if (cp == RG_SCH_CMN_NOR_CP)
10436    {
10437       splSfIdx = (splSubfrmIdx == 4)? 1: 0;   
10438    }
10439    else
10440    {
10441       splSfIdx = (splSubfrmIdx == 3)? 1: 0;
10442    }
10443
10444    numCrs = rgSchCmnDwptsCrs[splSfIdx][antPortIdx];
10445
10446    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI-1; cfi++)
10447    { 
10448       /* If CFI is 2 and Ant Port is 4, don't consider the sym 1 CRS REs */  
10449       if (antPortIdx == 2 && cfi == 2)
10450       {
10451          numCrs -= 4;      
10452       }
10453       cellSch->dl.numReDwPts[cfi]  =  ((cell->splSubfrmCfg.dwPts - cfi)*
10454                                   RB_SCH_CMN_NUM_SCS_PER_RB) - numCrs;
10455    }
10456    /* DwPTS Scheduling Changes End */
10457
10458    if (cfg->maxDlBwPerUe == 0)
10459    {
10460       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10461    }
10462    else
10463    {
10464       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10465    }
10466    if (cfg->maxDlRetxBw == 0)
10467    {
10468       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10469    }
10470    else
10471    {
10472       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10473    }
10474    /* Fix: MUE_PERTTI_DL*/
10475    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10476    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10477    if (cfg->maxUePerDlSf == 0)
10478    {
10479       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10480    }
10481    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10482    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10483    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10484    {
10485       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
10486                       "Invalid configuration !: "
10487                       "maxCcchPerDlSf %u > maxUePerDlSf %u",
10488                    cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10489
10490       RETVALUE(RFAILED);
10491    }
10492    else if (!cfg->maxCcchPerDlSf)
10493    {
10494       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10495        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10496        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10497        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10498        * FLE crash in PHY as PHY has limit of 16 max*/
10499       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10500    }
10501    else
10502    {
10503       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10504    }
10505    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10506    {
10507       RETVALUE(RFAILED);
10508    }
10509
10510    /*ccpu00118273 - ADD - start */
10511    cmLListInit(&cellSch->dl.msg4RetxLst);
10512 #ifdef RGR_V1
10513    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10514 #endif
10515
10516 #ifdef RG_PHASE2_SCHED
10517    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10518    {
10519       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10520    }
10521    if (cfg->dlfsCfg.isDlFreqSel)
10522    {
10523       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10524       if (ret != ROK)
10525       {
10526          RETVALUE(RFAILED);
10527       }
10528    }
10529    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10530 #endif
10531
10532    /* Power related configuration */
10533    ret = rgSCHPwrCellCfg(cell, cfg);
10534    if (ret != ROK)
10535    {
10536       RETVALUE(RFAILED);
10537    }
10538
10539    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10540    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10541    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10542    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10543    cellSch->dl.msg4pAVal        = cfg->msg4pAVal;
10544    RETVALUE(ROK);
10545 }
10546 #else /* LTE_TDD */
10547 /**
10548  * @brief This function handles the configuration of cell for the first
10549  *        time by the scheduler.
10550  *
10551  * @details
10552  *
10553  *     Function: rgSCHCmnDlRgrCellCfg
10554  *     Purpose:  Configuration received is stored into the data structures
10555  *               Also, update the scheduler with the number of frames of
10556  *               RACH preamble transmission.
10557  *
10558  *     Invoked by: BO and Scheduler
10559  *
10560  *  @param[in]  RgSchCellCb*   cell
10561  *  @param[in]  RgrCellCfg*    cfg
10562  *  @param[in]  RgSchErrInfo*  err
10563  *  @return     S16
10564  *
10565  **/
10566 #ifdef ANSI
10567 PRIVATE S16 rgSCHCmnDlRgrCellCfg
10568 (
10569 RgSchCellCb             *cell,
10570 RgrCellCfg              *cfg,
10571 RgSchErrInfo            *err
10572 )
10573 #else
10574 PRIVATE S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
10575 RgSchCellCb             *cell;
10576 RgrCellCfg              *cfg;
10577 RgSchErrInfo            *err;
10578 #endif
10579 {
10580    S16                 ret;
10581    RgSchCmnCell        *cellSch;
10582    U8                   cp;
10583    U8                   numPdcchSym;
10584    U8                   noSymPerSlot;
10585    U8                   cfi;  
10586    U8                   cfiIdx;
10587
10588    TRC2(rgSCHCmnDlRgrCellCfg);
10589
10590    cellSch = RG_SCH_CMN_GET_CELL(cell);
10591
10592    /* Initialize the parameters with the ones received in the */
10593    /* configuration.                                          */
10594
10595    /* Added matrix 'rgRaPrmblToRaFrmTbl' for computation of RA
10596     * sub-frames from preamble format */
10597    cellSch->dl.numRaSubFrms = rgRaPrmblToRaFrmTbl[cell->rachCfg.preambleFormat];
10598
10599    /*[ccpu00138532]-ADD-fill the Msg4 Harq data */
10600    cell->dlHqCfg.maxMsg4HqTx = cfg->dlHqCfg.maxMsg4HqTx;                                                
10601    
10602    /* Msg4 Tx Delay = (HARQ_RTT * MAX_MSG4_HARQ_RETX)  + 
10603                        3 TTI (MAX L1+L2 processing delay at the UE) */
10604    cellSch->dl.msg4TxDelay = (cfg->dlHqCfg.maxMsg4HqTx-1) *
10605                                  rgSchCmnHarqRtt[7] + 3; 
10606
10607    if (cell->bwCfg.dlTotalBw <= 10)
10608    {
10609       cfiIdx = 1;
10610       numPdcchSym = 2;
10611    }
10612    else
10613    {
10614       cfiIdx = 0;
10615       numPdcchSym = 1;
10616    }
10617
10618    if (cell->isCpDlExtend == TRUE)
10619    {
10620       cp = RG_SCH_CMN_EXT_CP;
10621       noSymPerSlot = 6;
10622    }
10623    else
10624    {
10625       cp = RG_SCH_CMN_NOR_CP;
10626       noSymPerSlot = 7;
10627    }
10628
10629    /* Initializing the cqiToEffTbl and cqiToTbsTbl for every CFI value */
10630    for(cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, cfiIdx++)
10631    {   
10632       cellSch->dl.cqiToTbsTbl[0][cfi]   = rgSchCmnCqiToTbs[0][cp][cfiIdx];
10633 #ifdef EMTC_ENABLE      
10634       cellSch->dl.emtcCqiToTbsTbl[0][cfi]   = rgSchEmtcCmnCqiToTbs[0][cp][cfiIdx];
10635 #endif      
10636       cellSch->dl.cqiToEffTbl[0][cfi]   = rgSchCmnEffTbl[0][cp][rgSchCmnAntIdx\
10637                                                  [cell->numTxAntPorts]][cfiIdx];
10638       cellSch->dl.cqiToTbsTbl[1][cfi]   = rgSchCmnCqiToTbs[1][cp][cfiIdx];
10639 #ifdef EMTC_ENABLE      
10640       cellSch->dl.emtcCqiToTbsTbl[1][cfi]   = rgSchEmtcCmnCqiToTbs[1][cp][cfiIdx];
10641 #endif      
10642       cellSch->dl.cqiToEffTbl[1][cfi]   = rgSchCmnEffTbl[1][cp][rgSchCmnAntIdx\
10643                                                  [cell->numTxAntPorts]][cfiIdx];
10644    }
10645
10646    /* Initializing the values of CFI parameters */
10647    if(cell->dynCfiCb.isDynCfiEnb)
10648    {   
10649       /* If DCFI is enabled, current CFI value will start from 1 */
10650       cellSch->dl.currCfi = cellSch->dl.newCfi = 1;
10651    }
10652    else
10653    {
10654       /* If DCFI is disabled, current CFI value is set as default CFI value */
10655       cellSch->dl.currCfi = cellSch->cfiCfg.cfi;
10656       cellSch->dl.newCfi = cellSch->dl.currCfi;
10657    }   
10658
10659    /* Include CRS REs while calculating Efficiency
10660     * The number of Resource Elements occupied by CRS depends on Number of
10661     * Antenna Ports. Please refer to Section 6.10.1 of 3GPP TS 36.211 V8.8.0.
10662     * Also, please refer to Figures 6.10.1.2-1 and 6.10.1.2-2 for diagrammatic
10663     * details of the same. Please note that PDCCH overlap symbols would not
10664     * considered in CRS REs deduction */
10665    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++, numPdcchSym++)
10666    {
10667        cellSch->dl.noResPerRb[cfi]    = (((noSymPerSlot * RG_SCH_CMN_NUM_SLOTS_PER_SF)
10668             - numPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - rgSchCmnNumResForCrs[cell->numTxAntPorts];
10669    }           
10670
10671    if (cfg->maxDlBwPerUe == 0)
10672    {
10673       cellSch->dl.maxDlBwPerUe = RG_SCH_CMN_MAX_DL_BW_PERUE;
10674    }
10675    else
10676    {
10677       cellSch->dl.maxDlBwPerUe = cfg->maxDlBwPerUe;
10678    }
10679    if (cfg->maxDlRetxBw == 0)
10680    {
10681       cellSch->dl.maxDlRetxBw = RG_SCH_CMN_MAX_DL_RETX_BW;
10682    }
10683    else
10684    {
10685       cellSch->dl.maxDlRetxBw = cfg->maxDlRetxBw;
10686    }
10687    
10688    /* Fix: MUE_PERTTI_DL*/
10689    cellSch->dl.maxUePerDlSf = cfg->maxUePerDlSf;
10690    cellSch->dl.maxUeNewTxPerTti = cfg->maxDlUeNewTxPerTti;
10691    if (cfg->maxUePerDlSf == 0)
10692    {
10693       cellSch->dl.maxUePerDlSf = RG_SCH_CMN_MAX_UE_PER_DL_SF;
10694    }
10695    /* Fix: MUE_PERTTI_DL syed validating Cell Configuration */
10696    if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
10697    {
10698       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
10699             "FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
10700             cellSch->dl.maxUePerDlSf,
10701             cellSch->dl.maxUeNewTxPerTti);
10702       RETVALUE(RFAILED);
10703    }
10704    /*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
10705    if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
10706    {
10707       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid configuration !: "
10708             "maxCcchPerDlSf %u > maxUePerDlSf %u",
10709             cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
10710
10711       RETVALUE(RFAILED);
10712    }
10713    else if (!cfg->maxCcchPerDlSf)
10714    {
10715       /* ccpu00143032: maxCcchPerDlSf 0 means not configured by application
10716        * hence setting to maxUePerDlSf. If maxCcchPerDlSf is 0 then scheduler
10717        * does't consider CCCH allocation in MaxUePerTti cap. Hence more than
10718        * 4UEs getting schduled & SCH expects >16 Hq PDUs in a TTI which causes
10719        * FLE crash in PHY as PHY has limit of 16 max*/
10720       cellSch->dl.maxCcchPerDlSf = cfg->maxUePerDlSf;
10721    }
10722    else
10723    {
10724       cellSch->dl.maxCcchPerDlSf = cfg->maxCcchPerDlSf;
10725    }
10726
10727
10728    if (rgSCHCmnDlCnsdrCmnRt(cell, &cfg->dlCmnCodeRate) != ROK)
10729    {
10730       RETVALUE(RFAILED);
10731    }
10732    cmLListInit(&cellSch->dl.msg4RetxLst);
10733 #ifdef RGR_V1
10734    cmLListInit(&cellSch->dl.ccchSduRetxLst);
10735 #endif
10736
10737 #ifdef RG_PHASE2_SCHED
10738    if (cellSch->apisDlfs == NULLP) /* DFLS specific initialization */
10739    {
10740       cellSch->apisDlfs = &rgSchDlfsSchdTbl[cfg->dlfsSchdType];
10741    }
10742    if (cfg->dlfsCfg.isDlFreqSel)
10743    {
10744       ret = cellSch->apisDlfs->rgSCHDlfsCellCfg(cell, cfg, err);
10745       if (ret != ROK)
10746       {
10747          RETVALUE(RFAILED);
10748       }
10749    }
10750    cellSch->dl.isDlFreqSel = cfg->dlfsCfg.isDlFreqSel;
10751 #endif
10752
10753    /* Power related configuration */
10754    ret = rgSCHPwrCellCfg(cell, cfg);
10755    if (ret != ROK)
10756    {
10757       RETVALUE(RFAILED);
10758    }
10759
10760    cellSch->dl.bcchTxPwrOffset = cfg->bcchTxPwrOffset; 
10761    cellSch->dl.pcchTxPwrOffset = cfg->pcchTxPwrOffset; 
10762    cellSch->dl.rarTxPwrOffset  = cfg->rarTxPwrOffset; 
10763    cellSch->dl.phichTxPwrOffset  = cfg->phichTxPwrOffset; 
10764    RG_SCH_RESET_HCSG_DL_PRB_CNTR(&cellSch->dl);
10765    RETVALUE(ROK);
10766 }
10767 #endif /* LTE_TDD */
10768
10769 /***********************************************************
10770  *
10771  *     Func : rgSCHCmnUlCalcReqRbCeil
10772  *
10773  *     Desc : Calculate RB required to satisfy 'bytes' for
10774  *            a given CQI.
10775  *            Returns number of RBs such that requirement
10776  *            is necessarily satisfied (does a 'ceiling'
10777  *            computation).
10778  *
10779  *     Ret  : Required RBs (U8)
10780  *
10781  *     Notes:
10782  *
10783  *     File :
10784  *
10785  **********************************************************/
10786 #ifdef ANSI
10787 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil
10788 (
10789 U32            bytes,
10790 U8             cqi,
10791 RgSchCmnUlCell *cellUl
10792 )
10793 #else
10794 PUBLIC U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
10795 U32            bytes;
10796 U8             cqi;
10797 RgSchCmnUlCell *cellUl;
10798 #endif
10799 {
10800    U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
10801    TRC2(rgSCHCmnUlCalcReqRbCeil);
10802    RETVALUE((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
10803 }
10804
10805 /***********************************************************
10806  *
10807  *     Func : rgSCHCmnPrecompMsg3Vars
10808  *
10809  *     Desc : Precomputes the following for msg3 allocation:
10810  *            1. numSb and Imcs for msg size A
10811  *            2. numSb and Imcs otherwise
10812  *
10813  *     Ret  :
10814  *
10815  *     Notes: The corresponding vars in cellUl struct is filled
10816  *            up
10817  *
10818  *     File :
10819  *
10820  **********************************************************/
10821 #ifdef ANSI
10822 PRIVATE S16 rgSCHCmnPrecompMsg3Vars
10823 (
10824 RgSchCmnUlCell *cellUl,
10825 U8           ccchCqi,
10826 U16          msgSzA,
10827 U8           sbSize,
10828 Bool         isEcp
10829 )
10830 #else
10831 PRIVATE S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
10832 RgSchCmnUlCell *cellUl;
10833 U8           ccchCqi;
10834 U16          msgSzA;
10835 U8           sbSize;
10836 Bool         isEcp;
10837 #endif
10838 {
10839    U8 numSb;
10840    U8 ccchTbs;
10841    U8 ccchMcs;
10842    U8   numRb = 0;
10843    U8   iTbs = 0;
10844    U16  msg3GrntSz = 0;
10845
10846    TRC2(rgSCHCmnPrecompMsg3Vars);
10847
10848    if (ccchCqi > cellUl->max16qamCqi)
10849    {
10850       ccchCqi = cellUl->max16qamCqi;
10851    }
10852 /* #ifndef RG_SCH_CMN_EXP_CP_SUP For ECP Pick the index 1 */
10853    /* Fix */
10854    ccchTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10855    ccchMcs = rgSCHCmnUlGetIMcsFrmITbs(ccchTbs, CM_LTE_UE_CAT_1);
10856    
10857    /* MCS should fit in 4 bits in RAR */
10858    if (ccchMcs >= 15)
10859    {
10860       ccchMcs = 15;
10861    }
10862    
10863    /* Limit the ccchMcs to 15 as it
10864     * can be inferred from 36.213, section 6.2 that msg3 imcs
10865     * field is 4 bits.
10866     * Since, UE doesn't exist right now, we use CAT_1 for ue
10867     * category*/
10868    while((ccchMcs = (rgSCHCmnUlGetIMcsFrmITbs(
10869                       rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
10870                     ) >
10871                  RG_SCH_CMN_MAX_MSG3_IMCS)
10872    {
10873       ccchCqi--;
10874    }
10875    
10876    iTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
10877    
10878    if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
10879    {
10880       RETVALUE(RFAILED);
10881    }
10882    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(msgSzA, ccchCqi, cellUl), sbSize);
10883    
10884    numRb   = numSb * sbSize;
10885    msg3GrntSz = 8 * msgSzA;
10886
10887    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10888    {
10889       ++numSb;
10890       numRb   = numSb * sbSize;
10891    }
10892    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10893    {
10894       ++numSb;
10895    }
10896    /* Reversed(Corrected) the assignment for preamble-GrpA
10897     * Refer- TG36.321- section- 5.1.2*/
10898    cellUl->ra.prmblBNumSb = numSb;
10899    cellUl->ra.prmblBIMcs  = ccchMcs;
10900    numSb = RGSCH_CEIL(rgSCHCmnUlCalcReqRbCeil(RGSCH_MIN_MSG3_GRNT_SZ, \
10901                       ccchCqi, cellUl),
10902          sbSize);
10903
10904    numRb   = numSb * sbSize;
10905    msg3GrntSz = 8 * RGSCH_MIN_MSG3_GRNT_SZ;
10906    while( (rgTbSzTbl[0][iTbs][numRb - 1]) < msg3GrntSz)
10907    {
10908       ++numSb;
10909       numRb   = numSb * sbSize;
10910    }
10911    while (rgSchCmnMult235Tbl[numSb].match != numSb)
10912    {
10913       ++numSb;
10914    }
10915    /* Reversed(Corrected) the assignment for preamble-GrpA
10916     * Refer- TG36.321- section- 5.1.2*/
10917    cellUl->ra.prmblANumSb = numSb;
10918    cellUl->ra.prmblAIMcs  = ccchMcs;
10919    RETVALUE(ROK);
10920 }
10921
10922 PUBLIC U32 gPrntPucchDet=0;
10923
10924 #ifdef LTE_TDD
10925 /***********************************************************
10926  *
10927  *     Func : rgSCHCmnUlCalcAvailBw
10928  *
10929  *     Desc : Calculates bandwidth available for PUSCH scheduling.
10930  *
10931  *     Ret  : S16 (ROK/RFAILED)
10932  *
10933  *     Notes:
10934  *
10935  *     File :
10936  *
10937  **********************************************************/
10938 #ifdef ANSI
10939 PRIVATE S16 rgSCHCmnUlCalcAvailBw
10940 (
10941 RgSchCellCb    *cell,
10942 RgrCellCfg     *cellCfg,
10943 U8              cfi,
10944 U8             *rbStartRef,
10945 U8             *bwAvailRef
10946 )
10947 #else
10948 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
10949 RgSchCellCb   *cell;
10950 RgrCellCfg    *cellCfg;
10951 U8             cfi;  
10952 U8            *rbStartRef;
10953 U8            *bwAvailRef;
10954 #endif
10955 {
10956    U8  c        = 3;
10957    U8  ulBw     = cell->bwCfg.ulTotalBw;
10958    U8  n2Rb     = cell->pucchCfg.resourceSize;
10959    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
10960    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
10961    U8  n1Cs     = cell->pucchCfg.cyclicShift;
10962
10963    U8  n1PerRb;
10964    U8  totalCce;
10965    U16 n1Max;
10966    U8  n1Rb;
10967    U32 mixedRb;
10968    U8  exclRb; /* RBs to exclude */
10969    U8  n1RbPart;
10970    U8  puschRbStart;
10971    /* To avoid PUCCH and PUSCH collision issue */
10972    U8  P;
10973    U8  n1PlusOne;
10974    U8  mi;
10975    /* Maximum value of M as per Table 10.1-1 */
10976    U8  M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
10977
10978    TRC2(rgSCHCmnUlCalcAvailBw);
10979
10980    if (cell->isCpUlExtend)
10981    {
10982       c = 2;
10983    }
10984
10985    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
10986
10987    /* Considering the max no. of CCEs for PUSCH BW calculation 
10988     * based on min mi value */
10989    if (cell->ulDlCfgIdx == 0 || cell->ulDlCfgIdx == 6)
10990    {
10991       mi = 1;
10992    }
10993    else
10994    { 
10995       mi = 0;
10996    }
10997    
10998    totalCce = cell->dynCfiCb.cfi2NCceTbl[mi][cfi];
10999
11000    P        = rgSCHCmnGetPValFrmCCE(cell, totalCce-1);
11001    n1PlusOne = cell->rgSchTddNpValTbl[P + 1];
11002    n1Max    = (M[cell->ulDlCfgIdx] - 1)*n1PlusOne + (totalCce-1) + n1Pucch;
11003
11004    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11005     * TS 36.211  */
11006    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11007    n1Rb = (n1Max - n1RbPart)/ n1PerRb;
11008    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11009
11010    /* get the total Number of RB's to be excluded for PUSCH */
11011    /* ccpu00137339 */
11012    if(n1Pucch < n1RbPart)
11013    {
11014       exclRb = n2Rb;
11015    }
11016    else
11017    {
11018       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11019    }
11020    puschRbStart = exclRb/2 + 1; 
11021
11022    /* Num of PUCCH RBs = puschRbStart*2 */
11023    if (puschRbStart * 2 >= ulBw)
11024    {
11025       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11026       RETVALUE(RFAILED);
11027    }
11028
11029    *rbStartRef = puschRbStart;
11030    *bwAvailRef = ulBw -  puschRbStart * 2;
11031  
11032    if(cell->pucchCfg.maxPucchRb !=0 && 
11033          (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11034    {
11035       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11036    }
11037     
11038    RETVALUE(ROK);
11039 }
11040 #else
11041
11042 /***********************************************************
11043  *
11044  *     Func : rgSCHCmnUlCalcAvailBw
11045  *
11046  *     Desc : Calculates bandwidth available for PUSCH scheduling.
11047  *
11048  *     Ret  : S16 (ROK/RFAILED)
11049  *
11050  *     Notes:
11051  *
11052  *     File :
11053  *
11054  **********************************************************/
11055 #ifdef ANSI
11056 PRIVATE S16 rgSCHCmnUlCalcAvailBw
11057 (
11058 RgSchCellCb    *cell,
11059 RgrCellCfg     *cellCfg,
11060 U8              cfi,
11061 U8             *rbStartRef,
11062 U8             *bwAvailRef
11063 )
11064 #else
11065 PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
11066 RgSchCellCb   *cell;
11067 RgrCellCfg    *cellCfg;
11068 U8             cfi;
11069 U8            *rbStartRef;
11070 U8            *bwAvailRef;
11071 #endif
11072 {
11073    U8  c        = 3;
11074    U8  ulBw     = cell->bwCfg.ulTotalBw;
11075    U8  n2Rb     = cell->pucchCfg.resourceSize;
11076    U8  pucchDeltaShft = cell->pucchCfg.deltaShift;
11077    U16 n1Pucch  = cell->pucchCfg.n1PucchAn;
11078    U8  n1Cs     = cell->pucchCfg.cyclicShift;
11079    U8  n1PerRb;
11080    U8  totalCce;
11081    U16 n1Max;
11082    U8  n1Rb;
11083    U32 mixedRb;
11084    U8  exclRb; /* RBs to exclude */
11085    U8  n1RbPart;
11086    U8  puschRbStart;
11087 #ifdef LTE_ADV
11088    U16 numOfN3PucchRb;
11089    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);  
11090 #endif
11091    
11092    TRC2(rgSCHCmnUlCalcAvailBw);
11093
11094    if (cell->isCpUlExtend)
11095    {
11096       c = 2;
11097    }
11098
11099    n1PerRb  = c * 12 / pucchDeltaShft; /* 12/18/36 */
11100
11101    totalCce = cell->dynCfiCb.cfi2NCceTbl[0][cfi];
11102
11103    n1Max    = n1Pucch + totalCce-1;
11104
11105    /* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in 
11106     * TS 36.211  */
11107    n1RbPart = (c*n1Cs)/pucchDeltaShft;
11108    n1Rb = (U8)((n1Max - n1RbPart) / n1PerRb);
11109    mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
11110
11111    /* get the total Number of RB's to be excluded for PUSCH */
11112    /* ccpu00137339 */
11113    if(n1Pucch < n1RbPart)
11114    {
11115       exclRb = n2Rb;
11116    }
11117    else
11118    {
11119       exclRb = n2Rb + mixedRb + n1Rb; /* RBs to exclude */
11120    }
11121    /*Support for PUCCH Format 3*/
11122 #ifdef LTE_ADV
11123    if (cell->isPucchFormat3Sptd)
11124    {
11125       numOfN3PucchRb = RGSCH_CEIL(cellSch->dl.maxUePerDlSf,5); 
11126       exclRb = exclRb + numOfN3PucchRb;
11127    }
11128 #endif
11129    puschRbStart = exclRb/2 + 1;
11130
11131    if(gPrntPucchDet)
11132    {
11133 #ifndef ALIGN_64BIT
11134            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
11135         cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11136 #else
11137            printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
11138         cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
11139 #endif
11140    }
11141
11142    if (puschRbStart*2 >= ulBw)
11143    {
11144       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
11145       RETVALUE(RFAILED);
11146    }
11147
11148    *rbStartRef = puschRbStart;
11149    *bwAvailRef = ulBw - puschRbStart * 2;
11150
11151    if(cell->pucchCfg.maxPucchRb !=0 && 
11152       (puschRbStart * 2 > cell->pucchCfg.maxPucchRb))
11153    {
11154       cell->dynCfiCb.maxCfi = RGSCH_MIN(cfi-1, cell->dynCfiCb.maxCfi);
11155    }
11156    
11157    RETVALUE(ROK);
11158 }
11159 #endif
11160
11161
11162
11163 /***********************************************************
11164  *
11165  *     Func : rgSCHCmnUlCellInit
11166  *
11167  *     Desc : Uplink scheduler initialisation for cell.
11168  *
11169  *     Ret  : S16
11170  *
11171  *     Notes:
11172  *
11173  *     File :
11174  *
11175  **********************************************************/
11176 #ifdef ANSI
11177 PRIVATE S16 rgSCHCmnUlCellInit
11178 (
11179  RgSchCellCb  *cell,
11180  RgrCellCfg   *cellCfg
11181  )
11182 #else
11183 PRIVATE S16 rgSCHCmnUlCellInit(cell, cellCfg)
11184    RgSchCellCb *cell;
11185    RgrCellCfg  *cellCfg;
11186 #endif
11187 {
11188    S16            ret;
11189    RgSchCmnUlCell *cellUl      = RG_SCH_CMN_GET_UL_CELL(cell);
11190    U8             maxUePerUlSf = cellCfg->maxUePerUlSf;
11191 #ifdef RGR_V1
11192    /* Added configuration for maximum number of MSG3s */
11193    U8             maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
11194 #endif
11195    U8             maxUlBwPerUe = cellCfg->maxUlBwPerUe;
11196    U8             sbSize       = cellCfg->puschSubBand.size;
11197    U8             i;
11198    U8             rbStart;
11199    U8             bwAvail;
11200    U8             cfi;  
11201    U8             maxSbPerUe;
11202    U8             numSb;
11203 #ifdef LTE_TDD
11204    U16            ulDlCfgIdx = cell->ulDlCfgIdx;
11205    /* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
11206    U8             maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx]; 
11207    U8             ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL  * 2 */
11208    U8             maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
11209                                            [RGSCH_NUM_SUB_FRAMES-1];
11210    U16             subfrm;
11211    S8             dlIdx;
11212 #else
11213    U8             maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
11214 #endif
11215 #ifdef LTE_L2_MEAS
11216    U8             idx;
11217 #endif
11218    U8  iTbs;
11219 #if (defined(LTE_L2_MEAS) )
11220    Inst           inst         = cell->instIdx;
11221 #endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
11222    RgSchCmnCell      *cellSch =  (RgSchCmnCell *)(cell->sc.sch);
11223    
11224    TRC2(rgSCHCmnUlCellInit);
11225
11226    cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
11227    if (maxUePerUlSf == 0)
11228    {
11229       maxUePerUlSf = RG_SCH_CMN_MAX_UE_PER_UL_SF;
11230    }
11231 #ifdef RGR_V1
11232    if (maxMsg3PerUlSf == 0)
11233    {
11234       maxMsg3PerUlSf = RG_SCH_CMN_MAX_MSG3_PER_UL_SF;
11235    }
11236    /*  fixed the problem while sending raRsp 
11237     * if maxMsg3PerUlSf is greater than 
11238     * RGSCH_MAX_RNTI_PER_RARNTI 
11239     * */
11240    if(maxMsg3PerUlSf > RGSCH_MAX_RNTI_PER_RARNTI)
11241    {
11242       maxMsg3PerUlSf = RGSCH_MAX_RNTI_PER_RARNTI; 
11243    } 
11244
11245    if(maxMsg3PerUlSf > maxUePerUlSf)
11246    {
11247       maxMsg3PerUlSf =  maxUePerUlSf;   
11248    }
11249    
11250    /*cellUl->maxAllocPerUlSf = maxUePerUlSf + maxMsg3PerUlSf;*/
11251    /*Max MSG3 should be a subset of Max UEs*/
11252    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11253    cellUl->maxMsg3PerUlSf = maxMsg3PerUlSf;
11254 #else
11255    cellUl->maxAllocPerUlSf = maxUePerUlSf;
11256 #endif
11257    /* Fix: MUE_PERTTI_UL syed validating Cell Configuration */
11258    if (cellUl->maxAllocPerUlSf < cellUl->maxUeNewTxPerTti)
11259    {
11260       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
11261             "FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
11262             cellUl->maxAllocPerUlSf,
11263             cellUl->maxUeNewTxPerTti);
11264       RETVALUE(RFAILED);
11265    }
11266
11267 #ifdef LTE_L2_MEAS
11268 #ifdef LTE_TDD
11269    for(idx = 0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
11270 #else
11271    for(idx = 0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
11272 #endif
11273    {
11274
11275       ret = rgSCHUtlAllocSBuf(inst,  (Data **)&(cell->sfAllocArr[idx].
11276               ulUeInfo.ulAllocInfo), (cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc)));
11277       if (ret != ROK)
11278       {
11279             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
11280             RETVALUE(ret);
11281       }
11282    }
11283 #endif
11284    if (maxUlBwPerUe == 0)
11285    {
11286       /* ccpu00139362- Setting to configured UL BW instead of MAX BW(100)*/
11287       maxUlBwPerUe = cell->bwCfg.ulTotalBw;
11288    }
11289    cellUl->maxUlBwPerUe = maxUlBwPerUe;
11290
11291    /* FOR RG_SCH_CMN_EXT_CP_SUP */
11292    if (!cellCfg->isCpUlExtend)
11293    {
11294       cellUl->ulNumRePerRb = 12 * (14 - RGSCH_UL_SYM_DMRS_SRS);
11295    }
11296    else
11297    {
11298       cellUl->ulNumRePerRb = 12 * (12 - RGSCH_UL_SYM_DMRS_SRS);
11299    }
11300
11301    if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
11302    {
11303       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
11304       RETVALUE(RFAILED);
11305    }
11306         //Setting the subband size to 4 which is size of VRBG in 5GTF
11307 #ifdef RG_5GTF
11308         sbSize = MAX_5GTF_VRBG_SIZE;
11309 #endif
11310         
11311    maxSbPerUe = maxUlBwPerUe / sbSize;
11312    if (maxSbPerUe == 0)
11313    {
11314       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
11315          "maxUlBwPerUe/sbSize is zero");
11316       RETVALUE(RFAILED);
11317    }
11318    cellUl->maxSbPerUe = rgSchCmnMult235Tbl[maxSbPerUe].prvMatch;
11319
11320    /* CQI related updations */
11321    if ((!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->ulCmnCodeRate.ccchCqi))
11322          || (!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->trgUlCqi.trgCqi)))
11323    {
11324       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
11325          "Invalid cqi");
11326       RETVALUE(RFAILED);
11327    }
11328    cellUl->dfltUlCqi = cellCfg->ulCmnCodeRate.ccchCqi;
11329
11330    /* Changed the logic to determine maxUlCqi.
11331     * For a 16qam UE, maxUlCqi is the CQI Index at which
11332     * efficiency is as close as possible to RG_SCH_MAX_CODE_RATE_16QAM
11333     * Refer to 36.213-8.6.1 */
11334     for (i = RG_SCH_CMN_UL_NUM_CQI - 1;i > 0; --i)
11335    {
11336       RLOG_ARG2(L_INFO,DBG_CELLID,cell->cellId,
11337             "CQI %u:iTbs %u",
11338             i, 
11339             rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i]);
11340 #ifdef MAC_SCH_STATS
11341       /* ccpu00128489 ADD Update mcs in hqFailStats here instead of at CRC 
11342        * since CQI to MCS mapping does not change. The only exception is for 
11343        * ITBS = 19 where the MCS can be 20 or 21 based on the UE cat. We 
11344        * choose 20, instead of 21, ie UE_CAT_3 */
11345       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11346       RG_SCH_CMN_UL_TBS_TO_MCS(iTbs, hqFailStats.ulCqiStat[i - 1].mcs);
11347 #endif
11348    }
11349    for (i = RG_SCH_CMN_UL_NUM_CQI - 1; i != 0; --i)
11350    {
11351       /* Fix for ccpu00123912*/
11352       iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
11353       if (iTbs <= RGSCH_UL_16QAM_MAX_ITBS) /* corresponds to 16QAM */
11354       {
11355          RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,
11356                          "16 QAM CQI %u", i);
11357          cellUl->max16qamCqi = i;
11358          break;
11359       }
11360    }
11361
11362 #ifdef EMTC_ENABLE
11363    /* Precompute useful values for RA msg3 */
11364    ret = rgSCHCmnPrecompEmtcMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11365          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11366    if (ret != ROK)
11367    {
11368       RETVALUE(ret);
11369    }
11370 #endif   
11371
11372    /* Precompute useful values for RA msg3 */
11373    ret = rgSCHCmnPrecompMsg3Vars(cellUl, cellCfg->ulCmnCodeRate.ccchCqi,
11374          cell->rachCfg.msgSizeGrpA, sbSize, cell->isCpUlExtend);
11375    if (ret != ROK)
11376    {
11377       RETVALUE(ret);
11378    }
11379
11380    cellUl->sbSize  = sbSize;
11381    
11382 #ifdef LTE_TDD  
11383    cellUl->numUlSubfrms = maxSubfrms;
11384
11385    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->ulSfArr,
11386             cellUl->numUlSubfrms * sizeof(RgSchUlSf));
11387
11388    if (ret != ROK)
11389    {
11390       cellUl->numUlSubfrms = 0;
11391       RETVALUE(ret);
11392    }
11393
11394    /* store the DL subframe corresponding to the PUSCH offset
11395     * in their respective UL subframe */
11396    for(i=0; i < RGSCH_NUM_SUB_FRAMES; i++)
11397    {
11398       if(rgSchTddPuschTxKTbl[ulDlCfgIdx][i] != 0)
11399       {
11400          subfrm = (i + rgSchTddPuschTxKTbl[ulDlCfgIdx][i]) % \
11401                                  RGSCH_NUM_SUB_FRAMES;
11402          subfrm = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subfrm]-1;
11403          dlIdx = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][i]-1;
11404          RGSCH_ARRAY_BOUND_CHECK( cell->instIdx, ulToDlMap, subfrm);
11405          ulToDlMap[subfrm] = dlIdx;
11406       }
11407    }
11408    /* Copy the information in the remaining UL subframes based
11409     * on number of HARQ processes */
11410    for(i=maxUlsubfrms; i < maxSubfrms; i++)
11411    {
11412       subfrm = i-maxUlsubfrms;
11413       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, i);
11414       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, ulToDlMap, subfrm)
11415       ulToDlMap[i] = ulToDlMap[subfrm];
11416    }
11417 #endif
11418
11419    for (cfi = 1; cfi < RG_SCH_CMN_MAX_CFI; cfi++)
11420    {
11421 #ifdef LTE_TDD        
11422       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11423 #else
11424       ret = rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, &rbStart, &bwAvail); 
11425 #endif
11426       if (ret != ROK)
11427       {
11428          RETVALUE(ret);
11429       }
11430
11431       if (cfi == 1)
11432       {
11433          cell->ulAvailBw = bwAvail;
11434       }
11435
11436       numSb = bwAvail/sbSize; 
11437
11438       cell->dynCfiCb.bwInfo[cfi].startRb  = rbStart;
11439       cell->dynCfiCb.bwInfo[cfi].numSb    = numSb;
11440    }
11441
11442    if(0 == cell->dynCfiCb.maxCfi)
11443    {
11444       RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId, 
11445                "Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
11446                cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi, 
11447                cell->pucchCfg.maxPucchRb);
11448             
11449       RETVALUE(RFAILED);
11450    }
11451
11452    /* DMRS values */
11453    cellUl->dmrsArrSize = cell->dynCfiCb.bwInfo[1].numSb;
11454    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cellUl->dmrsArr,
11455          cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11456    if (ret != ROK)
11457    {
11458       RETVALUE(ret);
11459    }
11460    for (i = 0; i < cellUl->dmrsArrSize; ++i)
11461    {
11462       cellUl->dmrsArr[i] = cellCfg->puschSubBand.dmrs[i];
11463    }
11464  
11465    /* Init subframes */
11466    for (i = 0; i < maxSubfrms; ++i)
11467    {
11468       ret = rgSCHUtlUlSfInit(cell, &cellUl->ulSfArr[i], i,
11469                              cellUl->maxAllocPerUlSf);
11470       if (ret != ROK)
11471       {
11472          for (; i != 0; --i)
11473          {
11474             rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[i-1]);
11475          }
11476          /* ccpu00117052 - MOD - Passing double pointer
11477             for proper NULLP assignment*/
11478          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(cellUl->dmrsArr)),
11479                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11480 #ifdef LTE_TDD
11481          /* ccpu00117052 - MOD - Passing double pointer
11482             for proper NULLP assignment*/
11483          rgSCHUtlFreeSBuf(cell->instIdx,
11484             (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11485 #endif
11486          RETVALUE(ret);
11487       }
11488    }
11489    RG_SCH_RESET_HCSG_UL_PRB_CNTR(cellUl);
11490    RETVALUE(ROK);
11491 }
11492
11493 /**
11494  * @brief Scheduler processing on cell configuration.
11495  *
11496  * @details
11497  *
11498  *     Function : rgSCHCmnRgrCellCfg
11499  *
11500  *     This function does requisite initialisation
11501  *     and setup for scheduler1 when a cell is
11502  *     configured.
11503  *
11504  *  @param[in]  RgSchCellCb   *cell
11505  *  @param[in]  RgrCellCfg    *cellCfg
11506  *  @param[out] RgSchErrInfo  *err
11507  *  @return  S16
11508  *      -# ROK
11509  *      -# RFAILED
11510  **/
11511 #ifdef ANSI
11512 PUBLIC S16 rgSCHCmnRgrCellCfg
11513 (
11514 RgSchCellCb   *cell,
11515 RgrCellCfg    *cellCfg,
11516 RgSchErrInfo  *err
11517 )
11518 #else
11519 PUBLIC S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
11520 RgSchCellCb   *cell;
11521 RgrCellCfg    *cellCfg;
11522 RgSchErrInfo  *err;
11523 #endif
11524 {
11525    S16       ret;
11526    RgSchCmnCell *cellSch;
11527    TRC2(rgSCHCmnRgrCellCfg);
11528
11529    /* As part of RGR cell configuration, validate the CRGCellCfg
11530     * There is no trigger for crgCellCfg from SC1 */
11531    /* Removed failure check for Extended CP */
11532
11533    if (((ret = rgSCHUtlAllocSBuf(cell->instIdx,
11534       (Data**)&(cell->sc.sch), (sizeof(RgSchCmnCell)))) != ROK))
11535    {
11536       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,  
11537          "Memory allocation FAILED");
11538       err->errCause = RGSCHERR_SCH_CFG;
11539       RETVALUE(ret);
11540    }
11541    cellSch = (RgSchCmnCell *)(cell->sc.sch);
11542    cellSch->cfiCfg = cellCfg->cfiCfg;
11543    cellSch->trgUlCqi.trgCqi = cellCfg->trgUlCqi.trgCqi;
11544    /* Initialize the scheduler refresh timer queues */
11545    cellSch->tmrTqCp.nxtEnt = 0;
11546    cellSch->tmrTqCp.tmrLen = RG_SCH_CMN_NUM_REFRESH_Q;
11547
11548    /* RACHO Intialize the RACH ded Preamble Information */
11549    rgSCHCmnCfgRachDedPrm(cell);
11550 #ifdef LTE_TDD
11551    /* Initialize 'Np' value for each 'p' used for
11552     * HARQ ACK/NACK reception */
11553    rgSCHCmnDlNpValInit(cell);
11554 #endif
11555
11556    /* Initialize 'Np' value for each 'p' used for
11557     * HARQ ACK/NACK reception */
11558 #ifdef LTE_TDD
11559    rgSCHCmnDlNpValInit(cell);
11560 #endif
11561
11562    /* Now perform uplink related initializations  */
11563    ret = rgSCHCmnUlCellInit(cell, cellCfg);
11564    if (ret != ROK)
11565    {
11566       /* There is no downlink deinit to be performed */
11567       err->errCause = RGSCHERR_SCH_CFG;
11568       RETVALUE(ret);
11569    }
11570    ret = rgSCHCmnDlRgrCellCfg(cell, cellCfg, err);
11571    if (ret != ROK)
11572    {
11573       err->errCause = RGSCHERR_SCH_CFG;
11574       RETVALUE(ret);
11575    }
11576    /* DL scheduler has no initializations to make */
11577    /* As of now DL scheduler always returns ROK   */
11578
11579    rgSCHCmnGetDciFrmtSizes(cell);
11580    rgSCHCmnGetCqiDciFrmt2AggrLvl(cell);
11581 #ifdef EMTC_ENABLE 
11582    rgSCHCmnGetEmtcDciFrmtSizes(cell);
11583    rgSCHCmnGetCqiEmtcDciFrmt2AggrLvl(cell);
11584 #endif /* EMTC_ENABLE  */
11585
11586 #ifdef EMTC_ENABLE   
11587    if(TRUE == cellCfg->emtcEnable)
11588    {
11589       cellSch->apisEmtcUl = &rgSchEmtcUlSchdTbl[0];
11590       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11591       if (ret != ROK)
11592       {
11593          RETVALUE(ret);
11594       }
11595    }
11596 #endif
11597    cellSch->apisUl = &rgSchUlSchdTbl[RG_SCH_CMN_GET_UL_SCHED_TYPE(cell)];
11598    ret = cellSch->apisUl->rgSCHRgrUlCellCfg(cell, cellCfg, err);
11599    if (ret != ROK)
11600    {
11601       RETVALUE(ret);
11602    }
11603 #ifdef EMTC_ENABLE   
11604    if(TRUE == cellCfg->emtcEnable)
11605    {
11606       cellSch->apisEmtcDl = &rgSchEmtcDlSchdTbl[0];
11607       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11608       if (ret != ROK)
11609       {
11610          RETVALUE(ret);
11611       }
11612    }
11613 #endif
11614    cellSch->apisDl = &rgSchDlSchdTbl[RG_SCH_CMN_GET_DL_SCHED_TYPE(cell)];
11615 #ifdef LTEMAC_SPS
11616    /* Perform SPS specific initialization for the cell */
11617    ret = rgSCHCmnSpsCellCfg(cell, cellCfg, err);
11618    if (ret != ROK)
11619    {
11620       RETVALUE(ret);
11621    }
11622 #endif
11623    ret = cellSch->apisDl->rgSCHRgrDlCellCfg(cell, cellCfg, err);
11624    if (ret != ROK)
11625    {
11626       RETVALUE(ret);
11627    }
11628    rgSCHCmnInitVars(cell);
11629
11630    RETVALUE(ROK);
11631 }  /* rgSCHCmnRgrCellCfg*/
11632
11633 \f
11634 /**
11635  * @brief This function handles the reconfiguration of cell.
11636  *
11637  * @details
11638  *
11639  *     Function: rgSCHCmnRgrCellRecfg
11640  *     Purpose:  Update the reconfiguration parameters.
11641  *
11642  *     Invoked by: Scheduler
11643  *
11644  *  @param[in]  RgSchCellCb*  cell
11645  *  @return  Void
11646  *
11647  **/
11648 #ifdef ANSI
11649 PUBLIC S16 rgSCHCmnRgrCellRecfg
11650 (
11651 RgSchCellCb             *cell,
11652 RgrCellRecfg            *recfg,
11653 RgSchErrInfo            *err
11654 )
11655 #else
11656 PUBLIC S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
11657 RgSchCellCb             *cell;
11658 RgrCellRecfg            *recfg;
11659 RgSchErrInfo            *err;
11660 #endif
11661 {
11662    S16                  ret;
11663    RgSchCmnCell         *cellSch = RG_SCH_CMN_GET_CELL(cell);
11664    RgSchCmnUlCell       *cellUl  = RG_SCH_CMN_GET_UL_CELL(cell);
11665
11666    TRC2(rgSCHCmnRgrCellRecfg);
11667
11668    if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
11669    {
11670       U8   oldCqi = cellUl->dfltUlCqi;
11671       if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
11672       {
11673          err->errCause = RGSCHERR_SCH_CFG;
11674          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
11675             "Invalid cqi");
11676          RETVALUE(RFAILED);
11677       }
11678       cellUl->dfltUlCqi = recfg->ulCmnCodeRate.ccchCqi;
11679       ret = rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11680             cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11681       if (ret != ROK)
11682       {
11683          cellUl->dfltUlCqi = oldCqi;
11684          rgSCHCmnPrecompMsg3Vars(cellUl, recfg->ulCmnCodeRate.ccchCqi,
11685                cell->rachCfg.msgSizeGrpA, cellUl->sbSize, cell->isCpUlExtend);
11686          RETVALUE(ret);
11687       }
11688    }
11689
11690    if (recfg->recfgTypes & RGR_CELL_DL_CMNRATE_RECFG)
11691    {
11692       if (rgSCHCmnDlCnsdrCmnRt(cell, &recfg->dlCmnCodeRate) != ROK)
11693       {
11694          err->errCause = RGSCHERR_SCH_CFG;
11695          RETVALUE(RFAILED);
11696       }
11697    }
11698  
11699 #ifdef EMTC_ENABLE  
11700    if(TRUE == cell->emtcEnable) 
11701    {
11702       /* Invoke UL sched for cell Recfg */
11703       ret = cellSch->apisEmtcUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11704       if (ret != ROK)
11705       {
11706          RETVALUE(RFAILED);
11707       }
11708
11709       /* Invoke DL sched for cell Recfg */
11710       ret = cellSch->apisEmtcDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11711       if (ret != ROK)
11712       {
11713          RETVALUE(RFAILED);
11714       }
11715    }
11716    else
11717 #endif
11718    {
11719    /* Invoke UL sched for cell Recfg */
11720    ret = cellSch->apisUl->rgSCHRgrUlCellRecfg(cell, recfg, err);
11721    if (ret != ROK)
11722    {
11723       RETVALUE(RFAILED);
11724    }
11725
11726    /* Invoke DL sched for cell Recfg */
11727    ret = cellSch->apisDl->rgSCHRgrDlCellRecfg(cell, recfg, err);
11728    if (ret != ROK)
11729    {
11730       RETVALUE(RFAILED);
11731    }
11732    }
11733
11734    if (recfg->recfgTypes & RGR_CELL_DLFS_RECFG)
11735    {
11736       ret = cellSch->apisDlfs->rgSCHDlfsCellRecfg(cell, recfg, err);
11737       if (ret != ROK)
11738       {
11739          RETVALUE(RFAILED);
11740       }
11741       cellSch->dl.isDlFreqSel = recfg->dlfsRecfg.isDlFreqSel;
11742    }
11743
11744    if (recfg->recfgTypes & RGR_CELL_PWR_RECFG)
11745    {
11746       ret = rgSCHPwrCellRecfg(cell, recfg);
11747       if (ret != ROK)
11748       {
11749          RETVALUE(RFAILED);
11750       }
11751    }
11752
11753    RETVALUE(ROK);
11754 }
11755
11756 /***********************************************************
11757  *
11758  *     Func : rgSCHCmnUlCellDeinit
11759  *
11760  *     Desc : Uplink scheduler de-initialisation for cell.
11761  *
11762  *     Ret  : S16
11763  *
11764  *     Notes:
11765  *
11766  *     File :
11767  *
11768  **********************************************************/
11769 #ifdef ANSI
11770 PRIVATE Void rgSCHCmnUlCellDeinit
11771 (
11772 RgSchCellCb *cell
11773 )
11774 #else
11775 PRIVATE Void rgSCHCmnUlCellDeinit(cell)
11776 RgSchCellCb *cell;
11777 #endif
11778 {
11779    RgSchCmnUlCell   *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
11780    U8               ulSfIdx;
11781 #ifdef LTE_TDD
11782    U8        maxSubfrms = cellUl->numUlSubfrms;
11783 #endif
11784 #ifdef LTE_L2_MEAS
11785    CmLList       *lnk = NULLP;
11786    RgSchL2MeasCb *measCb;
11787 #endif
11788    TRC2(rgSCHCmnUlCellDeinit);
11789 #ifdef LTE_L2_MEAS
11790 #ifdef LTE_TDD
11791    for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
11792 #else
11793    for(ulSfIdx = 0; ulSfIdx < RGSCH_NUM_SUB_FRAMES; ulSfIdx++)
11794 #endif
11795    {
11796       if(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo != NULLP)
11797       {
11798          /* ccpu00117052 - MOD - Passing double pointer
11799             for proper NULLP assignment*/
11800          rgSCHUtlFreeSBuf(cell->instIdx,
11801          (Data **)(&(cell->sfAllocArr[ulSfIdx].ulUeInfo.ulAllocInfo)),
11802          cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc));
11803
11804          /* ccpu00117052 - DEL - removed explicit NULLP assignment
11805             as it is done in above utility function */
11806       }
11807    }
11808    /* Free the memory allocated to measCb */
11809    lnk = cell->l2mList.first;
11810    while(lnk != NULLP)
11811    {
11812       measCb = (RgSchL2MeasCb *)lnk->node;
11813       cmLListDelFrm(&cell->l2mList, lnk);
11814       lnk = lnk->next;
11815    /* ccpu00117052 - MOD - Passing double pointer
11816    for proper NULLP assignment*/
11817       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,\
11818                           sizeof(RgSchL2MeasCb));
11819    }
11820 #endif
11821    if (cellUl->dmrsArr != NULLP)
11822    {
11823       /* ccpu00117052 - MOD - Passing double pointer
11824       for proper NULLP assignment*/
11825       rgSCHUtlFreeSBuf(cell->instIdx,(Data **)(&(cellUl->dmrsArr)),
11826                cellUl->dmrsArrSize * sizeof(*cellUl->dmrsArr));
11827    }
11828    /* De-init subframes */
11829 #ifdef LTE_TDD
11830    for (ulSfIdx = 0; ulSfIdx < maxSubfrms; ++ulSfIdx)
11831 #else
11832    for (ulSfIdx = 0; ulSfIdx < RG_SCH_CMN_UL_NUM_SF; ++ulSfIdx)
11833 #endif
11834    {
11835       rgSCHUtlUlSfDeinit(cell, &cellUl->ulSfArr[ulSfIdx]);
11836    }
11837
11838 #ifdef LTE_TDD
11839    if (cellUl->ulSfArr != NULLP)
11840    {
11841       /* ccpu00117052 - MOD - Passing double pointer
11842       for proper NULLP assignment*/
11843       rgSCHUtlFreeSBuf(cell->instIdx,
11844          (Data **)(&(cellUl->ulSfArr)), maxSubfrms * sizeof(RgSchUlSf));
11845    }
11846 #endif
11847
11848    RETVOID;
11849 }
11850
11851 /**
11852  * @brief Scheduler processing for cell delete.
11853  *
11854  * @details
11855  *
11856  *     Function : rgSCHCmnCellDel
11857  *
11858  *     This functions de-initialises and frees memory
11859  *     taken up by scheduler1 for the entire cell.
11860  *
11861  *  @param[in]  RgSchCellCb  *cell
11862  *  @return  Void
11863  **/
11864 #ifdef ANSI
11865 PUBLIC Void rgSCHCmnCellDel
11866 (
11867 RgSchCellCb  *cell
11868 )
11869 #else
11870 PUBLIC Void rgSCHCmnCellDel(cell)
11871 RgSchCellCb  *cell;
11872 #endif
11873 {
11874    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
11875    TRC2(rgSCHCmnCellDel);
11876
11877 #ifdef LTE_L2_MEAS
11878    glblTtiCnt = 0;
11879 #endif
11880    if (cellSch == NULLP)
11881    {
11882       RETVOID;
11883    }
11884    /* Perform the deinit for the UL scheduler */
11885    rgSCHCmnUlCellDeinit(cell);
11886 #ifdef EMTC_ENABLE
11887    if(TRUE == cell->emtcEnable)
11888    {
11889       if (cellSch->apisEmtcUl)
11890       {
11891          cellSch->apisEmtcUl->rgSCHFreeUlCell(cell);
11892       }
11893    }
11894 #endif 
11895    if (cellSch->apisUl)
11896    {
11897       /* api pointer checks added (here and below in
11898        * this function). pl check. - antriksh */
11899       cellSch->apisUl->rgSCHFreeUlCell(cell);
11900    }
11901
11902    /* Perform the deinit for the DL scheduler */
11903    cmLListInit(&cellSch->dl.taLst);
11904    if (cellSch->apisDl)
11905    {
11906       cellSch->apisDl->rgSCHFreeDlCell(cell);
11907    }
11908 #ifdef EMTC_ENABLE
11909    if (cellSch->apisEmtcDl)
11910    {
11911       rgSCHEmtcInitTaLst(&cellSch->dl);
11912
11913       cellSch->apisEmtcDl->rgSCHFreeDlCell(cell);
11914    }
11915 #endif
11916
11917    /* DLFS de-initialization */
11918    if (cellSch->dl.isDlFreqSel && cellSch->apisDlfs)
11919    {
11920       cellSch->apisDlfs->rgSCHDlfsCellDel(cell);
11921    }
11922
11923    rgSCHPwrCellDel(cell);
11924 #ifdef LTEMAC_SPS
11925    rgSCHCmnSpsCellDel(cell);
11926 #endif
11927
11928    /* ccpu00117052 - MOD - Passing double pointer
11929    for proper NULLP assignment*/
11930    rgSCHUtlFreeSBuf(cell->instIdx,
11931       (Data**)(&(cell->sc.sch)), (sizeof(RgSchCmnCell)));
11932    RETVOID;
11933 }  /* rgSCHCmnCellDel */
11934
11935 \f
11936 /**
11937  * @brief This function validates QOS parameters for DL.
11938  *
11939  * @details
11940  *
11941  *     Function: rgSCHCmnValidateDlQos
11942  *     Purpose:  This function validates QOS parameters for DL.
11943  *
11944  *     Invoked by: Scheduler
11945  *
11946  *  @param[in] CrgLchQosCfg    *dlQos
11947  *  @return                    S16
11948  *
11949  **/
11950 #ifdef ANSI
11951 PRIVATE S16 rgSCHCmnValidateDlQos
11952 (
11953 RgrLchQosCfg            *dlQos
11954 )
11955 #else
11956 PRIVATE S16 rgSCHCmnValidateDlQos(dlQos)
11957 RgrLchQosCfg            *dlQos;
11958 #endif
11959 {
11960    U8 qci = dlQos->qci;
11961
11962    TRC2(rgSCHCmnValidateDlQos);
11963
11964    if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
11965    {
11966       RETVALUE(RFAILED);
11967    }
11968
11969    if ((qci >= RG_SCH_CMN_GBR_QCI_START) &&
11970        (qci <= RG_SCH_CMN_GBR_QCI_END))
11971    {
11972       if ((dlQos->mbr == 0) || (dlQos->mbr < dlQos->gbr))
11973       {
11974          RETVALUE(RFAILED);
11975       }
11976    }
11977    RETVALUE(ROK);
11978 }
11979
11980 /**
11981  * @brief Scheduler invocation on logical channel addition.
11982  *
11983  * @details
11984  *
11985  *     Function : rgSCHCmnRgrLchCfg
11986  *
11987  *     This functions does required processing when a new
11988  *     (dedicated) logical channel is added. Assumes lcg
11989  *     pointer in ulLc is set.
11990  *
11991  *  @param[in]  RgSchCellCb  *cell
11992  *  @param[in]  RgSchUeCb    *ue
11993  *  @param[in]  RgSchDlLcCb  *dlLc
11994  *  @param[int] RgrLchCfg    *lcCfg
11995  *  @param[out] RgSchErrInfo *err
11996  *  @return  S16
11997  *      -# ROK
11998  *      -# RFAILED
11999  **/
12000 #ifdef ANSI
12001 PUBLIC S16 rgSCHCmnRgrLchCfg
12002 (
12003 RgSchCellCb  *cell,
12004 RgSchUeCb    *ue,
12005 RgSchDlLcCb  *dlLc,
12006 RgrLchCfg *lcCfg,
12007 RgSchErrInfo *err
12008 )
12009 #else
12010 PUBLIC S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
12011 RgSchCellCb  *cell;
12012 RgSchUeCb    *ue;
12013 RgSchDlLcCb  *dlLc;
12014 RgrLchCfg *lcCfg;
12015 RgSchErrInfo *err;
12016 #endif
12017 {
12018    S16 ret;
12019
12020    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12021
12022    TRC2(rgSCHCmnRgrLchCfg);
12023
12024    ret = rgSCHUtlAllocSBuf(cell->instIdx,
12025       (Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
12026    if (ret != ROK)
12027    {
12028       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
12029          "SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12030       err->errCause = RGSCHERR_SCH_CFG;
12031       RETVALUE(ret);
12032    }
12033    if(lcCfg->lcType != CM_LTE_LCH_DCCH)
12034    {
12035       ret = rgSCHCmnValidateDlQos(&lcCfg->dlInfo.dlQos);
12036       if (ret != ROK)
12037       {
12038          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
12039             "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12040          err->errCause = RGSCHERR_SCH_CFG;
12041          RETVALUE(ret);
12042       }
12043       /* Perform DL service activation in the scheduler */
12044       ((RgSchCmnDlSvc *)(dlLc->sch))->qci = lcCfg->dlInfo.dlQos.qci;
12045       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = rgSchCmnDlQciPrio[lcCfg->dlInfo.dlQos.qci - 1];
12046       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcCfg->dlInfo.dlQos.gbr * \
12047       RG_SCH_CMN_REFRESH_TIME)/100;
12048       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcCfg->dlInfo.dlQos.mbr * \
12049       RG_SCH_CMN_REFRESH_TIME)/100;
12050    }
12051    else
12052    {
12053      /*assigning highest priority to DCCH */
12054     ((RgSchCmnDlSvc *)(dlLc->sch))->prio=RG_SCH_CMN_DCCH_PRIO; 
12055    }   
12056    dlLc->ue = ue;
12057    dlLc->lcType=lcCfg->lcType;
12058
12059 #ifdef EMTC_ENABLE
12060    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12061    {
12062       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcCfg(cell, ue,dlLc ,lcCfg, err);
12063       if (ret != ROK)
12064       {
12065          RETVALUE(RFAILED);
12066       }
12067    }
12068    else
12069 #endif 
12070    {
12071       ret = cellSch->apisDl->rgSCHRgrDlLcCfg(cell, ue, dlLc, lcCfg, err);
12072       if (ret != ROK)
12073       {
12074          RETVALUE(RFAILED);
12075       }
12076    }
12077    
12078 #ifdef EMTC_ENABLE
12079    if(TRUE == ue->isEmtcUe)
12080    {
12081       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12082       if (ret != ROK)
12083       {
12084          RETVALUE(RFAILED);
12085       }
12086    }
12087    else
12088 #endif 
12089    {
12090    ret = cellSch->apisUl->rgSCHRgrUlLcCfg(cell, ue, lcCfg, err);
12091    if (ret != ROK)
12092    {
12093       RETVALUE(RFAILED);
12094    }
12095    }
12096    
12097 #ifdef LTE_ADV
12098    if (ue->numSCells)
12099    {
12100       rgSCHSCellDlLcCfg(cell, ue, dlLc);
12101    }
12102 #endif
12103
12104
12105 #ifdef LTEMAC_SPS
12106    if(lcCfg->dlInfo.dlSpsCfg.isSpsEnabled)
12107    {
12108       /* Invoke SPS module if SPS is enabled for the service */
12109       ret = rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err);
12110       if (ret != ROK)
12111       {
12112          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "rgSchCmnRgrLchCfg(): "
12113             "SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
12114          err->errCause = RGSCHERR_SCH_CFG;
12115          RETVALUE(RFAILED);
12116       }
12117    }
12118 #endif
12119
12120    RETVALUE(ROK);
12121 }
12122
12123 /**
12124  * @brief Scheduler invocation on logical channel addition.
12125  *
12126  * @details
12127  *
12128  *     Function : rgSCHCmnRgrLchRecfg
12129  *
12130  *     This functions does required processing when an existing
12131  *     (dedicated) logical channel is reconfigured. Assumes lcg
12132  *     pointer in ulLc is set to the old value.
12133  *     Independent of whether new LCG is meant to be configured,
12134  *     the new LCG scheduler information is accessed and possibly modified.
12135  *
12136  *  @param[in]  RgSchCellCb  *cell
12137  *  @param[in]  RgSchUeCb    *ue
12138  *  @param[in]  RgSchDlLcCb  *dlLc
12139  *  @param[int] RgrLchRecfg  *lcRecfg
12140  *  @param[out] RgSchErrInfo *err
12141  *  @return  S16
12142  *      -# ROK
12143  *      -# RFAILED
12144  **/
12145 #ifdef ANSI
12146 PUBLIC S16 rgSCHCmnRgrLchRecfg
12147 (
12148 RgSchCellCb  *cell,
12149 RgSchUeCb    *ue,
12150 RgSchDlLcCb  *dlLc,
12151 RgrLchRecfg  *lcRecfg,
12152 RgSchErrInfo *err
12153 )
12154 #else
12155 PUBLIC S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
12156 RgSchCellCb  *cell;
12157 RgSchUeCb    *ue;
12158 RgSchDlLcCb  *dlLc;
12159 RgrLchRecfg  *lcRecfg;
12160 RgSchErrInfo *err;
12161 #endif
12162 {
12163    S16   ret;
12164    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12165
12166    TRC2(rgSCHCmnRgrLchRecfg)
12167
12168    if(dlLc->lcType != CM_LTE_LCH_DCCH)
12169    {
12170       ret = rgSCHCmnValidateDlQos(&lcRecfg->dlRecfg.dlQos);
12171    
12172       if (ret != ROK)
12173       {
12174          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
12175                "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12176          err->errCause = RGSCHERR_SCH_CFG;
12177          RETVALUE(ret);
12178       }
12179       if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
12180       {
12181          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
12182             "not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12183          err->errCause = RGSCHERR_SCH_CFG;
12184          RETVALUE(ret);
12185       }
12186       ((RgSchCmnDlSvc *)(dlLc->sch))->gbr = (lcRecfg->dlRecfg.dlQos.gbr * \
12187       RG_SCH_CMN_REFRESH_TIME)/100;
12188       ((RgSchCmnDlSvc *)(dlLc->sch))->mbr = (lcRecfg->dlRecfg.dlQos.mbr * \
12189       RG_SCH_CMN_REFRESH_TIME)/100;
12190    }
12191    else
12192    {
12193       /*assigning highest priority to DCCH */
12194       ((RgSchCmnDlSvc *)(dlLc->sch))->prio = RG_SCH_CMN_DCCH_PRIO; 
12195    }
12196    
12197 #ifdef EMTC_ENABLE
12198    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12199    {
12200       ret = cellSch->apisEmtcDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12201       if (ret != ROK)
12202       {
12203          RETVALUE(RFAILED);
12204       }
12205       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12206       if (ret != ROK)
12207       {
12208          RETVALUE(RFAILED);
12209       }
12210    }
12211    else
12212 #endif 
12213    {
12214    ret = cellSch->apisDl->rgSCHRgrDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12215    if (ret != ROK)
12216    {
12217       RETVALUE(RFAILED);
12218    }
12219    ret = cellSch->apisUl->rgSCHRgrUlLcRecfg(cell, ue, lcRecfg, err);
12220    if (ret != ROK)
12221    {
12222       RETVALUE(RFAILED);
12223    }
12224    }
12225     
12226 #ifdef LTEMAC_SPS
12227    if (lcRecfg->recfgTypes & RGR_DL_LC_SPS_RECFG)
12228    {
12229       /* Invoke SPS module if SPS is enabled for the service */
12230       if(lcRecfg->dlRecfg.dlSpsRecfg.isSpsEnabled)
12231       {
12232          ret = rgSCHCmnSpsDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
12233          if (ret != ROK)
12234          {
12235             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"SPS re-configuration not "
12236                   "supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
12237          }
12238       }
12239       RETVALUE(ROK);
12240    }
12241 #endif
12242
12243    RETVALUE(ROK);
12244 }
12245
12246 /**
12247  * @brief Scheduler invocation on logical channel addition.
12248  *
12249  * @details
12250  *
12251  *     Function : rgSCHCmnRgrLcgCfg
12252  *
12253  *     This functions does required processing when a new
12254  *     (dedicated) logical channel is added. Assumes lcg
12255  *     pointer in ulLc is set.
12256  *
12257  *  @param[in]  RgSchCellCb  *cell,
12258  *  @param[in]  RgSchUeCb    *ue,
12259  *  @param[in]  RgSchLcgCb   *lcg,
12260  *  @param[in]  RgrLcgCfg    *lcgCfg,
12261  *  @param[out] RgSchErrInfo *err
12262  *  @return  S16
12263  *      -# ROK
12264  *      -# RFAILED
12265  **/
12266 #ifdef ANSI
12267 PUBLIC S16 rgSCHCmnRgrLcgCfg
12268 (
12269 RgSchCellCb  *cell,
12270 RgSchUeCb    *ue,
12271 RgSchLcgCb   *lcg,
12272 RgrLcgCfg    *lcgCfg,
12273 RgSchErrInfo *err
12274 )
12275 #else
12276 PUBLIC S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
12277 RgSchCellCb  *cell;
12278 RgSchUeCb    *ue;
12279 RgSchLcgCb   *lcg;
12280 RgrLcgCfg    *lcgCfg;
12281 RgSchErrInfo *err;
12282 #endif
12283 {
12284    S16 ret;
12285    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12286    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
12287
12288    TRC2(rgSCHCmnRgrLcgCfg);
12289
12290    ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12291    ulLcg->effGbr  = ulLcg->cfgdGbr;
12292    ulLcg->deltaMbr = ((lcgCfg->ulInfo.mbr - lcgCfg->ulInfo.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12293    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12294
12295 #ifdef EMTC_ENABLE
12296    if(TRUE == ue->isEmtcUe)
12297    {
12298       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12299       if (ret != ROK)
12300       {
12301          RETVALUE(RFAILED);
12302       }
12303    }
12304    else
12305 #endif
12306    {
12307    ret = cellSch->apisUl->rgSCHRgrUlLcgCfg(cell, ue, lcg, lcgCfg, err);
12308    if (ret != ROK)
12309    {
12310       RETVALUE(RFAILED);
12311    }
12312    }
12313    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12314    {
12315       /* Indicate MAC that this LCG is GBR LCG */
12316       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcgCfg->ulInfo.lcgId, TRUE);
12317    }
12318    RETVALUE(ROK);
12319 }
12320
12321 /**
12322  * @brief Scheduler invocation on logical channel addition.
12323  *
12324  * @details
12325  *
12326  *     Function : rgSCHCmnRgrLcgRecfg
12327  *
12328  *     This functions does required processing when a new
12329  *     (dedicated) logical channel is added. Assumes lcg
12330  *     pointer in ulLc is set.
12331  *
12332  *  @param[in]  RgSchCellCb  *cell,
12333  *  @param[in]  RgSchUeCb    *ue,
12334  *  @param[in]  RgSchLcgCb   *lcg,
12335  *  @param[in]  RgrLcgRecfg  *reCfg,
12336  *  @param[out] RgSchErrInfo *err
12337  *  @return  S16
12338  *      -# ROK
12339  *      -# RFAILED
12340  **/
12341 #ifdef ANSI
12342 PUBLIC S16 rgSCHCmnRgrLcgRecfg
12343 (
12344 RgSchCellCb  *cell,
12345 RgSchUeCb    *ue,
12346 RgSchLcgCb   *lcg,
12347 RgrLcgRecfg  *reCfg,
12348 RgSchErrInfo *err
12349 )
12350 #else
12351 PUBLIC S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
12352 RgSchCellCb  *cell;
12353 RgSchUeCb    *ue;
12354 RgSchLcgCb   *lcg;
12355 RgrLcgRecfg  *reCfg;
12356 RgSchErrInfo *err;
12357 #endif
12358 {
12359    S16 ret;
12360    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12361    RgSchCmnLcg  *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
12362    
12363    TRC2(rgSCHCmnRgrLcgRecfg);
12364
12365    ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
12366    ulLcg->effGbr  = ulLcg->cfgdGbr;
12367    ulLcg->deltaMbr = ((reCfg->ulRecfg.mbr - reCfg->ulRecfg.gbr) * RG_SCH_CMN_REFRESH_TIME)/100;
12368    ulLcg->effDeltaMbr = ulLcg->deltaMbr;
12369  
12370 #ifdef EMTC_ENABLE
12371    if(TRUE == ue->isEmtcUe)
12372    {
12373       ret = cellSch->apisEmtcUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12374       if (ret != ROK)
12375       {
12376          RETVALUE(RFAILED);
12377       }
12378    }
12379    else
12380 #endif
12381    {
12382    ret = cellSch->apisUl->rgSCHRgrUlLcgRecfg(cell, ue, lcg, reCfg, err);
12383    if (ret != ROK)
12384    {
12385       RETVALUE(RFAILED);
12386    }
12387    }
12388    if (RGSCH_IS_GBR_BEARER(ulLcg->cfgdGbr))
12389    {
12390       /* Indicate MAC that this LCG is GBR LCG */
12391       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, TRUE);
12392    }
12393    else
12394    {
12395       /* In case of RAB modification */
12396       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, reCfg->ulRecfg.lcgId, FALSE);
12397    }
12398    RETVALUE(ROK);
12399 }
12400
12401 /***********************************************************
12402  *
12403  *     Func : rgSCHCmnRgrLchDel
12404  *
12405  *     Desc : Scheduler handling for a (dedicated)
12406  *             uplink logical channel being deleted.
12407  *
12408  *     Ret  :
12409  *
12410  *     Notes:
12411  *
12412  *     File :
12413  **********************************************************/
12414 #ifdef ANSI
12415 PUBLIC S16 rgSCHCmnRgrLchDel 
12416 (
12417 RgSchCellCb   *cell,
12418 RgSchUeCb     *ue,
12419 CmLteLcId     lcId,
12420 U8            lcgId
12421 )
12422 #else
12423 PUBLIC S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
12424 RgSchCellCb   *cell;
12425 RgSchUeCb     *ue;
12426 CmLteLcId     lcId;
12427 U8            lcgId;
12428 #endif
12429 {
12430    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12431    TRC2(rgSCHCmnRgrLchDel);
12432 #ifdef EMTC_ENABLE
12433    if(TRUE == ue->isEmtcUe)
12434    {
12435       cellSch->apisEmtcUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12436    }
12437    else
12438 #endif
12439    {
12440    cellSch->apisUl->rgSCHRgrUlLchDel(cell, ue, lcId, lcgId);
12441    }
12442    RETVALUE(ROK);
12443 }
12444
12445 /***********************************************************
12446  *
12447  *     Func : rgSCHCmnLcgDel
12448  *
12449  *     Desc : Scheduler handling for a (dedicated)
12450  *             uplink logical channel being deleted.
12451  *
12452  *     Ret  :
12453  *
12454  *     Notes:
12455  *
12456  *     File :
12457  *
12458  **********************************************************/
12459 #ifdef ANSI
12460 PUBLIC Void rgSCHCmnLcgDel
12461 (
12462 RgSchCellCb   *cell,
12463 RgSchUeCb     *ue,
12464 RgSchLcgCb    *lcg
12465 )
12466 #else
12467 PUBLIC Void rgSCHCmnLcgDel(cell, ue, lcg)
12468 RgSchCellCb   *cell;
12469 RgSchUeCb     *ue;
12470 RgSchLcgCb    *lcg;
12471 #endif
12472 {
12473    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12474    RgSchCmnLcg  *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
12475    TRC2(rgSCHCmnLcgDel);
12476
12477    if (lcgCmn == NULLP)
12478    {
12479       RETVOID;
12480    }
12481
12482    if (RGSCH_IS_GBR_BEARER(lcgCmn->cfgdGbr))
12483    {
12484       /* Indicate MAC that this LCG is GBR LCG */
12485       rgSCHUtlBuildNSendLcgReg(cell, ue->ueId, lcg->lcgId, FALSE);
12486    }
12487
12488 #ifdef LTEMAC_SPS
12489    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
12490    {
12491       rgSCHCmnSpsUlLcgDel(cell, ue, lcg);
12492    }
12493 #endif /* LTEMAC_SPS */
12494
12495    lcgCmn->effGbr     = 0;
12496    lcgCmn->reportedBs = 0;
12497    lcgCmn->cfgdGbr    = 0;
12498    /* set lcg bs to 0. Deletion of control block happens
12499     * at the time of UE deletion. */
12500    lcgCmn->bs = 0;
12501 #ifdef EMTC_ENABLE
12502    if(TRUE == ue->isEmtcUe)
12503    {
12504       cellSch->apisEmtcUl->rgSCHFreeUlLcg(cell, ue, lcg);
12505    }
12506    else
12507 #endif
12508    {
12509    cellSch->apisUl->rgSCHFreeUlLcg(cell, ue, lcg);
12510    }
12511    RETVOID;
12512 }
12513
12514 \f
12515 /**
12516  * @brief This function deletes a service from scheduler.
12517  *
12518  * @details
12519  *
12520  *     Function: rgSCHCmnFreeDlLc
12521  *     Purpose:  This function is made available through a FP for
12522  *               making scheduler aware of a service being deleted from UE.
12523  *
12524  *     Invoked by: BO and Scheduler
12525  *
12526  *  @param[in]  RgSchCellCb*  cell
12527  *  @param[in]  RgSchUeCb*    ue
12528  *  @param[in]  RgSchDlLcCb*  svc
12529  *  @return  Void
12530  *
12531  **/
12532 #ifdef ANSI
12533 PUBLIC Void rgSCHCmnFreeDlLc
12534 (
12535 RgSchCellCb                *cell,
12536 RgSchUeCb                  *ue,
12537 RgSchDlLcCb                *svc
12538 )
12539 #else
12540 PUBLIC Void rgSCHCmnFreeDlLc(cell, ue, svc)
12541 RgSchCellCb                *cell;
12542 RgSchUeCb                  *ue;
12543 RgSchDlLcCb                *svc;
12544 #endif
12545 {
12546    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
12547    TRC2(rgSCHCmnFreeDlLc);
12548    if (svc->sch == NULLP)
12549    {
12550       RETVOID;
12551    }
12552 #ifdef EMTC_ENABLE
12553     if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
12554     {
12555       cellSch->apisEmtcDl->rgSCHFreeDlLc(cell, ue, svc);
12556     }
12557     else
12558 #endif
12559    {
12560       cellSch->apisDl->rgSCHFreeDlLc(cell, ue, svc);
12561    }
12562
12563 #ifdef LTE_ADV
12564    if (ue->numSCells)
12565    {
12566       rgSCHSCellDlLcDel(cell, ue, svc);
12567    }
12568 #endif
12569
12570 #ifdef LTEMAC_SPS
12571    /* If SPS service, invoke SPS module */
12572    if (svc->dlLcSpsCfg.isSpsEnabled)
12573    {
12574       rgSCHCmnSpsDlLcDel(cell, ue, svc);
12575    }
12576 #endif
12577
12578    /* ccpu00117052 - MOD - Passing double pointer
12579    for proper NULLP assignment*/
12580    rgSCHUtlFreeSBuf(cell->instIdx,
12581          (Data**)(&(svc->sch)), (sizeof(RgSchCmnDlSvc)));
12582
12583 #ifdef LTE_ADV
12584    rgSCHLaaDeInitDlLchCb(cell, svc);
12585 #endif
12586
12587    RETVOID;
12588 }
12589
12590 #ifdef RGR_V1
12591
12592 /**
12593  * @brief This function Processes the Final Allocations
12594  *        made by the RB Allocator against the requested
12595  *        CCCH SDURetx Allocations.
12596  *
12597  * @details
12598  *
12599  *     Function: rgSCHCmnDlCcchSduRetxFnlz
12600  *     Purpose:  This function Processes the Final Allocations
12601  *               made by the RB Allocator against the requested
12602  *               CCCH Retx Allocations.
12603  *               Scans through the scheduled list of ccchSdu retrans
12604  *               fills the corresponding pdcch, adds the hqProc to
12605  *               the corresponding SubFrm and removes the hqP from
12606  *               cells retx List.
12607  *
12608  *     Invoked by: Common Scheduler
12609  *
12610  *  @param[in]  RgSchCellCb           *cell
12611  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12612  *  @return  Void
12613  *
12614  **/
12615 #ifdef ANSI
12616 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz
12617 (
12618 RgSchCellCb           *cell,
12619 RgSchCmnDlRbAllocInfo *allocInfo
12620 )
12621 #else
12622 PRIVATE Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
12623 RgSchCellCb           *cell;
12624 RgSchCmnDlRbAllocInfo *allocInfo;
12625 #endif
12626 {
12627    CmLList           *node;
12628    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12629    RgSchDlRbAlloc    *rbAllocInfo;
12630    RgSchDlHqProcCb   *hqP;
12631    RgSchUeCb         *ue;
12632    TRC2(rgSCHCmnDlCcchSduRetxFnlz);
12633
12634    /* Traverse through the Scheduled Retx List */
12635    node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
12636    while (node)
12637    {
12638       hqP = (RgSchDlHqProcCb *)(node->node);
12639       ue = hqP->hqE->ue;
12640       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
12641       node = node->next;
12642       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12643
12644       /* Remove the HqP from cell's ccchSduRetxLst */
12645       cmLListDelFrm(&cmnCellDl->ccchSduRetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12646       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12647
12648       /* Fix: syed dlAllocCb reset should be performed.
12649        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12650       rgSCHCmnDlUeResetTemp(ue, hqP);
12651    }
12652    /* Fix: syed dlAllocCb reset should be performed.
12653     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12654    node = allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst.first;
12655    while(node)
12656    {
12657       hqP = (RgSchDlHqProcCb *)(node->node);
12658       ue = hqP->hqE->ue;
12659       node = node->next;
12660       /* reset the UE allocation Information */
12661       rgSCHCmnDlUeResetTemp(ue, hqP);
12662    }
12663    RETVOID;
12664 }
12665 #endif
12666 /**
12667  * @brief This function Processes the Final Allocations
12668  *        made by the RB Allocator against the requested
12669  *        CCCH Retx Allocations.
12670  *
12671  * @details
12672  *
12673  *     Function: rgSCHCmnDlCcchRetxFnlz
12674  *     Purpose:  This function Processes the Final Allocations
12675  *               made by the RB Allocator against the requested
12676  *               CCCH Retx Allocations.
12677  *               Scans through the scheduled list of msg4 retrans
12678  *               fills the corresponding pdcch, adds the hqProc to
12679  *               the corresponding SubFrm and removes the hqP from
12680  *               cells retx List.
12681  *
12682  *     Invoked by: Common Scheduler
12683  *
12684  *  @param[in]  RgSchCellCb           *cell
12685  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12686  *  @return  Void
12687  *
12688  **/
12689 #ifdef ANSI
12690 PRIVATE Void rgSCHCmnDlCcchRetxFnlz
12691 (
12692 RgSchCellCb           *cell,
12693 RgSchCmnDlRbAllocInfo *allocInfo
12694 )
12695 #else
12696 PRIVATE Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
12697 RgSchCellCb           *cell;
12698 RgSchCmnDlRbAllocInfo *allocInfo;
12699 #endif
12700 {
12701    CmLList           *node;
12702    RgSchCmnDlCell    *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
12703    RgSchDlRbAlloc    *rbAllocInfo;
12704    RgSchDlHqProcCb   *hqP;
12705    RgSchRaCb         *raCb;
12706    TRC2(rgSCHCmnDlCcchRetxFnlz);
12707
12708    /* Traverse through the Scheduled Retx List */
12709    node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
12710    while (node)
12711    {
12712       hqP = (RgSchDlHqProcCb *)(node->node);
12713       raCb = hqP->hqE->raCb;
12714       rbAllocInfo = &raCb->rbAllocInfo;
12715       node = node->next;
12716       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12717
12718       /* Remove the HqP from cell's msg4RetxLst */
12719       cmLListDelFrm(&cmnCellDl->msg4RetxLst, &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
12720       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
12721       /* Fix: syed dlAllocCb reset should be performed.
12722        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12723       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12724       rgSCHCmnDlHqPResetTemp(hqP);
12725    }
12726    /* Fix: syed dlAllocCb reset should be performed.
12727     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12728    node = allocInfo->msg4Alloc.nonSchdMsg4RetxLst.first;
12729    while(node)
12730    {
12731       hqP = (RgSchDlHqProcCb *)(node->node);
12732       raCb = hqP->hqE->raCb;
12733       node = node->next;
12734       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12735       rgSCHCmnDlHqPResetTemp(hqP);
12736    }
12737    RETVOID;
12738 }
12739
12740 #ifdef RGR_V1
12741 /**
12742  * @brief This function Processes the Final Allocations
12743  *        made by the RB Allocator against the requested
12744  *        CCCH SDU tx Allocations.
12745  *
12746  * @details
12747  *
12748  *     Function: rgSCHCmnDlCcchSduTxFnlz
12749  *     Purpose:  This function Processes the Final Allocations
12750  *               made by the RB Allocator against the requested
12751  *               CCCH tx Allocations.
12752  *               Scans through the scheduled list of CCCH SDU trans
12753  *               fills the corresponding pdcch, adds the hqProc to
12754  *               the corresponding SubFrm and removes the hqP from
12755  *               cells tx List.
12756  *
12757  *     Invoked by: Common Scheduler
12758  *
12759  *  @param[in]  RgSchCellCb           *cell
12760  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12761  *  @return  Void
12762  *
12763  **/
12764 #ifdef ANSI
12765 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz
12766 (
12767 RgSchCellCb           *cell,
12768 RgSchCmnDlRbAllocInfo *allocInfo
12769 )
12770 #else
12771 PRIVATE Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
12772 RgSchCellCb           *cell;
12773 RgSchCmnDlRbAllocInfo *allocInfo;
12774 #endif
12775 {
12776    CmLList           *node;
12777    RgSchUeCb         *ueCb;
12778    RgSchDlRbAlloc    *rbAllocInfo;
12779    RgSchDlHqProcCb   *hqP;
12780    RgSchLchAllocInfo  lchSchdData;
12781    TRC2(rgSCHCmnDlCcchSduTxFnlz);
12782
12783    /* Traverse through the Scheduled Retx List */
12784    node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
12785    while (node)
12786    {
12787       hqP = (RgSchDlHqProcCb *)(node->node);
12788       ueCb = hqP->hqE->ue;
12789       node = node->next;
12790       rbAllocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
12791
12792       /* fill the pdcch and HqProc */
12793       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12794
12795       /* Remove the raCb from cell's toBeSchdLst */
12796       cmLListDelFrm(&cell->ccchSduUeLst, &ueCb->ccchSduLnk);
12797       ueCb->ccchSduLnk.node = (PTR)NULLP;
12798
12799       /* Fix : Resetting this required to avoid complication
12800        * in reestablishment case */
12801       ueCb->dlCcchInfo.bo = 0;
12802
12803       /* Indicate DHM of the CCCH LC scheduling */
12804       hqP->tbInfo[0].contResCe = NOTPRSNT;
12805       lchSchdData.lcId     = 0;
12806       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12807                              (RGSCH_MSG4_HDRSIZE);
12808       rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12809
12810       /* Fix: syed dlAllocCb reset should be performed.
12811        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12812       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12813    }
12814    /* Fix: syed dlAllocCb reset should be performed.
12815     * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12816    node = allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst.first;
12817    while(node)
12818    {
12819       hqP = (RgSchDlHqProcCb *)(node->node);
12820       ueCb = hqP->hqE->ue;
12821       node = node->next;
12822       /* Release HqProc */
12823       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12824       /*Fix: Removing releasing of TB1 as it will not exist for CCCH SDU and hence caused a crash*/
12825       /*rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12826       /* reset the UE allocation Information */
12827       rgSCHCmnDlUeResetTemp(ueCb, hqP);
12828    }
12829    RETVOID;
12830 }
12831
12832 #endif
12833 /**
12834  * @brief This function Processes the Final Allocations
12835  *        made by the RB Allocator against the requested
12836  *        CCCH tx Allocations.
12837  *
12838  * @details
12839  *
12840  *     Function: rgSCHCmnDlCcchTxFnlz
12841  *     Purpose:  This function Processes the Final Allocations
12842  *               made by the RB Allocator against the requested
12843  *               CCCH tx Allocations.
12844  *               Scans through the scheduled list of msg4 trans
12845  *               fills the corresponding pdcch, adds the hqProc to
12846  *               the corresponding SubFrm and removes the hqP from
12847  *               cells tx List.
12848  *
12849  *     Invoked by: Common Scheduler
12850  *
12851  *  @param[in]  RgSchCellCb           *cell
12852  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
12853  *  @return  Void
12854  *
12855  **/
12856 #ifdef ANSI
12857 PRIVATE Void rgSCHCmnDlCcchTxFnlz
12858 (
12859 RgSchCellCb           *cell,
12860 RgSchCmnDlRbAllocInfo *allocInfo
12861 )
12862 #else
12863 PRIVATE Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
12864 RgSchCellCb           *cell;
12865 RgSchCmnDlRbAllocInfo *allocInfo;
12866 #endif
12867 {
12868    CmLList           *node;
12869    RgSchRaCb         *raCb;
12870    RgSchDlRbAlloc    *rbAllocInfo;
12871    RgSchDlHqProcCb   *hqP;
12872    RgSchLchAllocInfo  lchSchdData;
12873    TRC2(rgSCHCmnDlCcchTxFnlz);
12874
12875    /* Traverse through the Scheduled Retx List */
12876    node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
12877    while (node)
12878    {
12879       hqP = (RgSchDlHqProcCb *)(node->node);
12880       raCb = hqP->hqE->raCb;
12881       node = node->next;
12882       rbAllocInfo = &raCb->rbAllocInfo;
12883
12884       /* fill the pdcch and HqProc */
12885       rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP);
12886       /* MSG4 Fix Start */
12887      
12888       rgSCHRamRmvFrmRaInfoSchdLst(cell, raCb);
12889       /* MSG4 Fix End */     
12890
12891       /* Indicate DHM of the CCCH LC scheduling */
12892       lchSchdData.lcId     = 0;
12893       lchSchdData.schdData = hqP->tbInfo[0].ccchSchdInfo.totBytes -
12894          (RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE);
12895       /* TRansmitting presence of cont Res CE across MAC-SCH interface to
12896        * identify CCCH SDU transmissions which need to be done
12897        * without the
12898        * contention resolution CE*/
12899       hqP->tbInfo[0].contResCe = PRSNT_NODEF;
12900       /*Dont add lc if only cont res CE is being transmitted*/
12901       if(raCb->dlCcchInfo.bo)
12902       {
12903          rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, &hqP->tbInfo[0]);
12904       }
12905       else
12906       {
12907       }
12908       /* Fix: syed dlAllocCb reset should be performed.
12909        * zombie info in dlAllocCb leading to crash rbNum wraparound */ 
12910       cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
12911       rgSCHCmnDlHqPResetTemp(hqP);
12912    }
12913    node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
12914    while(node)
12915    {
12916       hqP = (RgSchDlHqProcCb *)(node->node);
12917       raCb = hqP->hqE->raCb;
12918       node = node->next;
12919       rbAllocInfo = &raCb->rbAllocInfo;
12920       /* Release HqProc */
12921       rgSCHDhmRlsHqpTb(hqP, 0, FALSE);
12922       /*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
12923       /*      rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
12924       /* reset the UE allocation Information */
12925       cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
12926       rgSCHCmnDlHqPResetTemp(hqP);
12927    }
12928
12929    RETVOID;
12930 }
12931 /* R8 Upgrade */
12932 /**
12933  * @brief This function calculates the BI Index to be sent in the Bi header
12934  * field.
12935  *
12936  * @details
12937  *     Function: rgSCHCmnGetBiIndex
12938  *     Purpose:  This function Processes utilizes the previous BI time value
12939  *     calculated and the difference last BI sent time and current time. To
12940  *     calculate the latest BI Index. It also considers the how many UE's
12941  *     Unserved in this subframe.
12942  *
12943  *     Invoked by: Common Scheduler
12944  *
12945  *  @param[in]  RgSchCellCb           *cell
12946  *  @param[in]  U32                   ueCount
12947  *  @return  U8
12948  *
12949  **/
12950 #ifdef ANSI
12951 PUBLIC U8 rgSCHCmnGetBiIndex
12952 (
12953 RgSchCellCb   *cell,
12954 U32           ueCount
12955 )
12956 #else
12957 PUBLIC U8 rgSCHCmnGetBiIndex(cell, ueCount)
12958 RgSchCellCb   *cell;
12959 U32           ueCount;
12960 #endif
12961 {
12962    S16  prevVal = 0;      /* To Store Intermediate Value */
12963    U16  newBiVal = 0;     /* To store Bi Value in millisecond */
12964    U8   idx = 0;
12965    U16  timeDiff = 0;
12966
12967    TRC2(rgSCHCmnGetBiIndex)
12968
12969    if (cell->biInfo.prevBiTime != 0)
12970    {
12971 #ifdef EMTC_ENABLE
12972       if(cell->emtcEnable == TRUE)
12973       {
12974          timeDiff =(RGSCH_CALC_SF_DIFF_EMTC(cell->crntTime, cell->biInfo.biTime));
12975       }
12976       else
12977 #endif
12978       {
12979          timeDiff =(RGSCH_CALC_SF_DIFF(cell->crntTime, cell->biInfo.biTime));
12980       }
12981
12982       prevVal = cell->biInfo.prevBiTime - timeDiff;
12983    }
12984    if (prevVal < 0)
12985    {
12986       prevVal = 0;
12987    }
12988    newBiVal = RG_SCH_CMN_GET_BI_VAL(prevVal,ueCount);
12989    /* To be used next time when BI is calculated */
12990 #ifdef EMTC_ENABLE
12991    if(cell->emtcEnable == TRUE)
12992    {
12993       RGSCHCPYTIMEINFO_EMTC(cell->crntTime, cell->biInfo.biTime)
12994    }
12995    else
12996 #endif
12997    {
12998       RGSCHCPYTIMEINFO(cell->crntTime, cell->biInfo.biTime)
12999    }
13000
13001   /* Search the actual BI Index from table Backoff Parameters Value  and
13002    * return that Index */
13003    do
13004    {
13005       if (rgSchCmnBiTbl[idx] > newBiVal)
13006       {
13007          break;
13008       }
13009       idx++;
13010    }while(idx < RG_SCH_CMN_NUM_BI_VAL-1);
13011    cell->biInfo.prevBiTime = rgSchCmnBiTbl[idx];
13012    /* For 16 Entries in Table 7.2.1 36.321.880 - 3 reserved so total 13 Entries */
13013    RETVALUE(idx); /* Returning reserved value from table UE treats it has 960 ms */
13014 } /* rgSCHCmnGetBiIndex */
13015
13016
13017 /**
13018  * @brief This function Processes the Final Allocations
13019  *        made by the RB Allocator against the requested
13020  *        RAR allocations. Assumption: The reuqested
13021  *        allocations are always satisfied completely.
13022  *        Hence no roll back.
13023  *
13024  * @details
13025  *
13026  *     Function: rgSCHCmnDlRaRspFnlz
13027  *     Purpose:  This function Processes the Final Allocations
13028  *               made by the RB Allocator against the requested.
13029  *               Takes care of PDCCH filling.
13030  *
13031  *     Invoked by: Common Scheduler
13032  *
13033  *  @param[in]  RgSchCellCb           *cell
13034  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13035  *  @return  Void
13036  *
13037  **/
13038 #ifdef ANSI
13039 PRIVATE Void rgSCHCmnDlRaRspFnlz
13040 (
13041 RgSchCellCb           *cell,
13042 RgSchCmnDlRbAllocInfo *allocInfo
13043 )
13044 #else
13045 PRIVATE Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
13046 RgSchCellCb           *cell;
13047 RgSchCmnDlRbAllocInfo *allocInfo;
13048 #endif
13049 {
13050    U32            rarCnt = 0;
13051    RgSchDlRbAlloc *raRspAlloc;
13052    RgSchDlSf      *subFrm = NULLP;
13053    RgSchRaCb      *raCb;
13054    RgSchErrInfo   err;
13055    CmLListCp      *reqLst;
13056    RgSchRaReqInfo *raReq;
13057    Bool           preamGrpA;
13058    RgSchUlAlloc   *ulAllocRef=NULLP;
13059    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13060    U8              allocRapidCnt = 0;
13061 #ifdef LTE_TDD
13062    U32            msg3SchdIdx = 0;
13063    U8             ulDlCfgIdx = cell->ulDlCfgIdx;
13064    U8             msg3Subfrm;
13065 #endif
13066
13067    TRC2(rgSCHCmnDlRaRspFnlz);
13068
13069    for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
13070    {
13071       raRspAlloc = &allocInfo->raRspAlloc[rarCnt];
13072       /* Having likely condition first for optimization */
13073       if (!raRspAlloc->pdcch)
13074       {
13075          continue;
13076       }
13077       else
13078       {
13079          subFrm = raRspAlloc->dlSf;
13080          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13081          /* Corrected RACH handling for multiple RAPIDs per RARNTI */
13082          allocRapidCnt = raRspAlloc->numRapids;
13083          while (allocRapidCnt)
13084          {
13085             raReq = (RgSchRaReqInfo *)(reqLst->first->node);
13086             /* RACHO: If dedicated preamble, then allocate UL Grant
13087              * (consequence of handover/pdcchOrder) and continue */
13088             if (RGSCH_IS_DEDPRM(cell, raReq->raReq.rapId))
13089             {
13090                rgSCHCmnHdlHoPo(cell, &subFrm->raRsp[rarCnt].contFreeUeLst,
13091                      raReq);
13092                cmLListDelFrm(reqLst, reqLst->first);
13093                allocRapidCnt--;
13094                /* ccpu00117052 - MOD - Passing double pointer
13095                for proper NULLP assignment*/
13096                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13097                      sizeof(RgSchRaReqInfo));
13098                continue;
13099             }
13100             /* ccpu00139815 */
13101             if(cell->overLoadBackOffEnab)
13102             {/* rach Overlaod conrol is triggerd, Skipping this rach */
13103                cmLListDelFrm(reqLst, reqLst->first);
13104                allocRapidCnt--;
13105                rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13106                      sizeof(RgSchRaReqInfo));
13107                continue;
13108             }
13109             /* Attempt to include each RA request into the RSP */
13110             /* Any failure in the procedure is considered to   */
13111             /* affect futher allocations in the same TTI. When */
13112             /* a failure happens, we break out and complete    */
13113             /* the processing for random access                */
13114             if (rgSCHRamCreateRaCb(cell, &raCb, &err) != ROK)
13115             {
13116                break;
13117             }
13118             /* Msg3 allocation request to USM */
13119             if (raReq->raReq.rapId < cell->rachCfg.sizeRaPreambleGrpA)
13120                preamGrpA = TRUE;
13121             else
13122                preamGrpA = FALSE;
13123             /*ccpu00128820 - MOD - Msg3 alloc double delete issue*/
13124             rgSCHCmnMsg3GrntReq(cell, raCb->tmpCrnti, preamGrpA, \
13125                   &(raCb->msg3HqProc), &ulAllocRef, &raCb->msg3HqProcId);
13126             if (ulAllocRef == NULLP)
13127             {
13128                rgSCHRamDelRaCb(cell, raCb, TRUE);
13129                break;
13130             }
13131             if (raReq->raReq.cqiPres)
13132             {
13133                raCb->ccchCqi = raReq->raReq.cqiIdx;
13134             }
13135             else
13136             {
13137                raCb->ccchCqi = cellDl->ccchCqi;
13138             }
13139             raCb->rapId = raReq->raReq.rapId;
13140             raCb->ta.pres    = TRUE;
13141             raCb->ta.val = raReq->raReq.ta;
13142             raCb->msg3Grnt = ulAllocRef->grnt;
13143             /* Populating the tpc value received */
13144             raCb->msg3Grnt.tpc = raReq->raReq.tpc;
13145             /* PHR handling for MSG3 */
13146             ulAllocRef->raCb = raCb;
13147 #ifndef LTE_TDD
13148             /* To the crntTime, add the MIN time at which UE will
13149              * actually send MSG3 i.e DL_DELTA+6 */
13150             raCb->msg3AllocTime = cell->crntTime;
13151             RGSCH_INCR_SUB_FRAME(raCb->msg3AllocTime, RG_SCH_CMN_MIN_MSG3_RECP_INTRVL);
13152 #else
13153             msg3SchdIdx = (cell->crntTime.slot+RG_SCH_CMN_DL_DELTA) % 
13154                                  RGSCH_NUM_SUB_FRAMES;
13155             /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
13156               special subframe */                       
13157             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][msg3SchdIdx] != 
13158                         RG_SCH_TDD_UL_SUBFRAME)
13159             {
13160                RGSCHCMNADDTOCRNTTIME(cell->crntTime,raCb->msg3AllocTime,
13161                                        RG_SCH_CMN_DL_DELTA)
13162                msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][
13163                                        raCb->msg3AllocTime.slot];
13164                RGSCHCMNADDTOCRNTTIME(raCb->msg3AllocTime, raCb->msg3AllocTime, 
13165                                  msg3Subfrm);
13166             }
13167 #endif
13168             cmLListAdd2Tail(&subFrm->raRsp[rarCnt].raRspLst, &raCb->rspLnk);
13169             raCb->rspLnk.node = (PTR)raCb;
13170             cmLListDelFrm(reqLst, reqLst->first);
13171             allocRapidCnt--;
13172             /* ccpu00117052 - MOD - Passing double pointer
13173             for proper NULLP assignment*/
13174             rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&raReq,
13175                   sizeof(RgSchRaReqInfo));
13176
13177             /* SR_RACH_STATS : RAR scheduled */
13178             rgNumRarSched++;
13179
13180          }
13181          /* R8 Upgrade */
13182          /* Fill subframe data members */
13183          subFrm->raRsp[rarCnt].raRnti = raRspAlloc->rnti;
13184          subFrm->raRsp[rarCnt].pdcch  = raRspAlloc->pdcch;
13185          subFrm->raRsp[rarCnt].tbSz   = raRspAlloc->tbInfo[0].bytesAlloc;
13186          /* Fill PDCCH data members */
13187          rgSCHCmnFillPdcch(cell, subFrm->raRsp[rarCnt].pdcch, raRspAlloc);
13188
13189          /* ccpu00139815 */
13190          if(cell->overLoadBackOffEnab)
13191          {/* rach Overlaod conrol is triggerd, Skipping this rach */
13192             subFrm->raRsp[rarCnt].backOffInd.pres = PRSNT_NODEF;
13193             subFrm->raRsp[rarCnt].backOffInd.val  = cell->overLoadBackOffval;
13194             continue;
13195          }
13196          else
13197          {
13198             subFrm->raRsp[rarCnt].backOffInd.pres = NOTPRSNT;
13199          }
13200
13201          /*[ccpu00125212] Avoiding sending of empty RAR in case of RAR window
13202            is short and UE is sending unauthorised preamble.*/
13203          reqLst = &cell->raInfo.raReqLst[raRspAlloc->raIndex];
13204          if ((raRspAlloc->biEstmt) && (reqLst->count))
13205          {
13206             subFrm->raRsp[0].backOffInd.pres = PRSNT_NODEF;
13207             /* Added as part of Upgrade */
13208             subFrm->raRsp[0].backOffInd.val =
13209             rgSCHCmnGetBiIndex(cell, reqLst->count);
13210
13211             /* SR_RACH_STATS : Back Off Inds */
13212             rgNumBI++;
13213
13214          }
13215          else if ((subFrm->raRsp[rarCnt].raRspLst.first == NULLP) &&
13216                (subFrm->raRsp[rarCnt].contFreeUeLst.first == NULLP))
13217          {
13218             /* Return the grabbed PDCCH */
13219             rgSCHUtlPdcchPut(cell, &subFrm->pdcchInfo, raRspAlloc->pdcch);
13220             subFrm->raRsp[rarCnt].pdcch = NULLP;
13221             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
13222                   "Not even one RaReq.");
13223             RETVOID;
13224          }
13225       }
13226       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, 
13227             "RNTI:%d Scheduled RAR @ (%u,%u) ",
13228             raRspAlloc->rnti, 
13229             cell->crntTime.sfn,
13230             cell->crntTime.slot);
13231    }
13232    RETVOID;
13233 }
13234
13235 /**
13236  * @brief This function computes rv.
13237  *
13238  * @details
13239  *
13240  *     Function: rgSCHCmnDlCalcRvForBcch
13241  *     Purpose:  This function computes rv.
13242  *
13243  *     Invoked by: Common Scheduler
13244  *
13245  *  @param[in]   RgSchCellCb     *cell
13246  *  @param[in]   Bool            si
13247  *  @param[in]   U16             i
13248  *  @return  U8
13249  *
13250  **/
13251 #ifdef ANSI
13252 PRIVATE U8 rgSCHCmnDlCalcRvForBcch
13253 (
13254 RgSchCellCb          *cell,
13255 Bool                 si,
13256 U16                  i
13257 )
13258 #else
13259 PRIVATE U8 rgSCHCmnDlCalcRvForBcch(cell, si, i)
13260 RgSchCellCb          *cell;
13261 Bool                 si;
13262 U16                  i;
13263 #endif
13264 {
13265    U8 k, rv;
13266    CmLteTimingInfo   frm;
13267    TRC2(rgSCHCmnDlCalcRvForBcch);
13268
13269    frm   = cell->crntTime;
13270    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
13271
13272    if(si)
13273    {
13274       k = i % 4;
13275    }
13276    else
13277    {
13278       k = (frm.sfn/2) % 4;
13279    }
13280    rv = RGSCH_CEIL(3*k, 2) % 4;
13281    RETVALUE(rv);
13282 }
13283
13284 /**
13285  * @brief This function Processes the Final Allocations
13286  *        made by the RB Allocator against the requested
13287  *        BCCH/PCCH allocations. Assumption: The reuqested
13288  *        allocations are always satisfied completely.
13289  *        Hence no roll back.
13290  *
13291  * @details
13292  *
13293  *     Function: rgSCHCmnDlBcchPcchFnlz
13294  *     Purpose:  This function Processes the Final Allocations
13295  *               made by the RB Allocator against the requested.
13296  *               Takes care of PDCCH filling.
13297  *
13298  *     Invoked by: Common Scheduler
13299  *
13300  *  @param[in]  RgSchCellCb           *cell
13301  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
13302  *  @return  Void
13303  *
13304  **/
13305 #ifdef ANSI
13306 PRIVATE Void rgSCHCmnDlBcchPcchFnlz
13307 (
13308 RgSchCellCb           *cell,
13309 RgSchCmnDlRbAllocInfo *allocInfo
13310 )
13311 #else
13312 PRIVATE Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
13313 RgSchCellCb           *cell;
13314 RgSchCmnDlRbAllocInfo *allocInfo;
13315 #endif
13316 {
13317    RgSchDlRbAlloc *rbAllocInfo;
13318    RgSchDlSf      *subFrm;
13319
13320 #ifdef LTE_TDD
13321    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
13322 #else
13323 #ifdef LTEMAC_HDFDD
13324    U8             nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13325 #else
13326    U8             nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13327 #endif
13328 #endif
13329
13330    /*  Moving variables to available scope for optimization */
13331    RgSchClcDlLcCb *pcch;
13332    RgSchClcBoRpt  *bo;
13333 #ifndef RGR_SI_SCH
13334    RgSchClcDlLcCb  *bcch;
13335    Bool           sendInd=TRUE;
13336 #endif
13337    RgSchCmnDlCell       *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
13338
13339    TRC2(rgSCHCmnDlBcchPcchFnlz);
13340
13341    /* handle PCCH */
13342    rbAllocInfo = &allocInfo->pcchAlloc;
13343    if (rbAllocInfo->pdcch)
13344    {
13345       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13346
13347       /* Added sfIdx calculation for TDD as well */
13348 #ifndef LTE_TDD
13349 #ifdef LTEMAC_HDFDD
13350       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13351 #else
13352       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13353 #endif
13354 #endif
13355       subFrm = rbAllocInfo->dlSf;
13356       pcch = rgSCHDbmGetPcch(cell);
13357       if(pcch == NULLP)
13358       {
13359          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
13360                "No Pcch Present");
13361          RETVOID;
13362       }
13363
13364       /* Added Dl TB count for paging message transmission*/
13365 #ifdef LTE_L2_MEAS
13366       cell->dlUlTbCnt.tbTransDlTotalCnt++;
13367 #endif      
13368       bo = (RgSchClcBoRpt *)pcch->boLst.first->node;
13369       cmLListDelFrm(&pcch->boLst, &bo->boLstEnt);
13370       /* ccpu00117052 - MOD - Passing double pointer
13371          for proper NULLP assignment*/
13372       rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13373       /* Fill subframe data members */
13374       subFrm->pcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13375       subFrm->pcch.pdcch  = rbAllocInfo->pdcch;
13376       /* Fill PDCCH data members */
13377       rgSCHCmnFillPdcch(cell, subFrm->pcch.pdcch, rbAllocInfo);
13378       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, pcch->lcId, TRUE);
13379       /* ccpu00132314-ADD-Update the tx power allocation info  
13380          TODO-Need to add a check for max tx power per symbol */ 
13381       subfrmAlloc->cmnLcInfo.pcchInfo.txPwrOffset = cellDl->pcchTxPwrOffset;   
13382    }
13383
13384    /* handle BCCH */
13385    rbAllocInfo = &allocInfo->bcchAlloc;
13386    if (rbAllocInfo->pdcch)
13387    {
13388       RgInfSfAlloc   *subfrmAlloc = &(cell->sfAllocArr[nextSfIdx]);
13389 #ifndef LTE_TDD
13390 #ifdef LTEMAC_HDFDD
13391       nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
13392 #else
13393       nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
13394 #endif
13395 #endif
13396       subFrm = rbAllocInfo->dlSf;
13397
13398       /* Fill subframe data members */
13399       subFrm->bcch.tbSize = rbAllocInfo->tbInfo[0].bytesAlloc;
13400       subFrm->bcch.pdcch  = rbAllocInfo->pdcch;
13401       /* Fill PDCCH data members */
13402       rgSCHCmnFillPdcch(cell, subFrm->bcch.pdcch, rbAllocInfo);
13403
13404       if(rbAllocInfo->schdFirst)
13405       {
13406 #ifndef RGR_SI_SCH
13407          bcch = rgSCHDbmGetFirstBcchOnDlsch(cell);
13408          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13409 #else
13410          /*Copy the SIB1 msg buff into interface buffer */
13411          SCpyMsgMsg(cell->siCb.crntSiInfo.sib1Info.sib1,
13412                rgSchCb[cell->instIdx].rgSchInit.region,
13413                rgSchCb[cell->instIdx].rgSchInit.pool,
13414                &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13415 #endif/*RGR_SI_SCH*/
13416          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13417             rgSCHCmnDlCalcRvForBcch(cell, FALSE, 0);
13418       }
13419       else
13420       {
13421          U16   i;
13422 #ifdef RGR_SI_SCH
13423          Buffer    *pdu;
13424
13425          i = cell->siCb.siCtx.i;
13426          /*Decrement the retransmission count */
13427          cell->siCb.siCtx.retxCntRem--;
13428
13429          /*Copy the SI msg buff into interface buffer */
13430          if(cell->siCb.siCtx.warningSiFlag == FALSE)
13431          {
13432             SCpyMsgMsg(cell->siCb.siArray[cell->siCb.siCtx.siId-1].si,
13433                   rgSchCb[cell->instIdx].rgSchInit.region,
13434                   rgSchCb[cell->instIdx].rgSchInit.pool,
13435                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13436          }
13437          else
13438          {
13439             pdu = rgSCHUtlGetWarningSiPdu(cell);
13440             RGSCH_NULL_CHECK(cell->instIdx, pdu);
13441             SCpyMsgMsg(pdu,
13442                   rgSchCb[cell->instIdx].rgSchInit.region,
13443                   rgSchCb[cell->instIdx].rgSchInit.pool,
13444                   &subfrmAlloc->cmnLcInfo.bcchInfo.pdu);
13445             if(cell->siCb.siCtx.retxCntRem == 0)
13446             {  
13447                rgSCHUtlFreeWarningSiPdu(cell);
13448                cell->siCb.siCtx.warningSiFlag  = FALSE;
13449
13450             }
13451          }
13452 #else
13453          bcch = rgSCHDbmGetSecondBcchOnDlsch(cell);
13454          bo = (RgSchClcBoRpt *)bcch->boLst.first->node;
13455          bo->retxCnt--;
13456          if(bo->retxCnt != cell->siCfg.retxCnt-1)
13457          {
13458             sendInd=FALSE;
13459          }
13460          i = bo->i;
13461 #endif/*RGR_SI_SCH*/
13462          subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv =
13463             rgSCHCmnDlCalcRvForBcch(cell, TRUE, i);
13464       }
13465
13466       /* Added Dl TB count for SIB1 and SI messages transmission.
13467        * This counter will be incremented only for the first transmission
13468        * (with RV 0) of these messages*/
13469 #ifdef LTE_L2_MEAS
13470       if(subFrm->bcch.pdcch->dci.u.format1aInfo.t.pdschInfo.allocInfo.rv == 0)
13471       {   
13472          cell->dlUlTbCnt.tbTransDlTotalCnt++;
13473       }
13474 #endif      
13475 #ifndef RGR_SI_SCH
13476       if(bo->retxCnt == 0)
13477       {
13478          cmLListDelFrm(&bcch->boLst, &bo->boLstEnt);
13479          /* ccpu00117052 - MOD - Passing double pointer
13480             for proper NULLP assignment*/
13481          rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&bo, sizeof(RgSchClcBoRpt));
13482       }
13483       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, bcch->lcId, sendInd);
13484 #else
13485       /*Fill the interface info */
13486       rgSCHUtlFillRgInfCmnLcInfo(subFrm, subfrmAlloc, NULLD, NULLD);
13487
13488       /* ccpu00132314-ADD-Update the tx power allocation info  
13489          TODO-Need to add a check for max tx power per symbol */ 
13490       subfrmAlloc->cmnLcInfo.bcchInfo.txPwrOffset = cellDl->bcchTxPwrOffset;   
13491
13492       /*mBuf has been already copied above */
13493 #endif/*RGR_SI_SCH*/
13494    }
13495
13496    RETVOID;
13497 }
13498
13499
13500 #if RG_UNUSED
13501 /**
13502  * @brief
13503  *
13504  * @details
13505  *
13506  *     Function: rgSCHCmnUlSetAllUnSched
13507  *     Purpose:
13508  *
13509  *     Invoked by: Common Scheduler
13510  *
13511  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13512  *  @return  Void
13513  *
13514  **/
13515 #ifdef ANSI
13516 PRIVATE Void rgSCHCmnUlSetAllUnSched
13517 (
13518 RgSchCmnUlRbAllocInfo *allocInfo
13519 )
13520 #else
13521 PRIVATE Void rgSCHCmnUlSetAllUnSched(allocInfo)
13522 RgSchCmnUlRbAllocInfo *allocInfo;
13523 #endif
13524 {
13525    CmLList            *node;
13526
13527    TRC2(rgSCHCmnUlSetAllUnSched);
13528
13529    node = allocInfo->contResLst.first;
13530    while (node)
13531    {
13532       rgSCHCmnUlMov2NonSchdCntResLst(allocInfo, (RgSchUeCb *)node->node);
13533       node = allocInfo->contResLst.first;
13534    }
13535
13536    node = allocInfo->retxUeLst.first;
13537    while (node)
13538    {
13539       rgSCHCmnUlMov2NonSchdRetxUeLst(allocInfo, (RgSchUeCb *)node->node);
13540       node = allocInfo->retxUeLst.first;
13541    }
13542
13543    node = allocInfo->ueLst.first;
13544    while (node)
13545    {
13546       rgSCHCmnUlMov2NonSchdUeLst(allocInfo, (RgSchUeCb *)node->node);
13547       node = allocInfo->ueLst.first;
13548    }
13549
13550    RETVOID;
13551 }
13552 #endif
13553
13554 /**
13555  * @brief
13556  *
13557  * @details
13558  *
13559  *     Function: rgSCHCmnUlAdd2CntResLst
13560  *     Purpose:
13561  *
13562  *     Invoked by: Common Scheduler
13563  *
13564  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13565  *  @param[in]  RgSchUeCb             *ue
13566  *  @return  Void
13567  *
13568  **/
13569 #ifdef ANSI
13570 PUBLIC Void rgSCHCmnUlAdd2CntResLst
13571 (
13572 RgSchCmnUlRbAllocInfo *allocInfo,
13573 RgSchUeCb             *ue
13574 )
13575 #else
13576 PUBLIC Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
13577 RgSchCmnUlRbAllocInfo *allocInfo;
13578 RgSchUeCb             *ue;
13579 #endif
13580 {
13581    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
13582    TRC2(rgSCHCmnUlAdd2CntResLst);
13583    cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
13584    ulAllocInfo->reqLnk.node = (PTR)ue;
13585    RETVOID;
13586 }
13587
13588 /**
13589  * @brief
13590  *
13591  * @details
13592  *
13593  *     Function: rgSCHCmnUlAdd2UeLst
13594  *     Purpose:
13595  *
13596  *     Invoked by: Common Scheduler
13597  *
13598  *  @param[out] RgSchCmnUlRbAllocInfo *allocInfo
13599  *  @param[in]  RgSchUeCb             *ue
13600  *  @return  Void
13601  *
13602  **/
13603 #ifdef ANSI
13604 PUBLIC Void rgSCHCmnUlAdd2UeLst
13605 (
13606 RgSchCellCb           *cell,
13607 RgSchCmnUlRbAllocInfo *allocInfo,
13608 RgSchUeCb             *ue
13609 )
13610 #else
13611 PUBLIC Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
13612 RgSchCellCb           *cell;
13613 RgSchCmnUlRbAllocInfo *allocInfo;
13614 RgSchUeCb             *ue;
13615 #endif
13616 {
13617    RgSchCmnUeUlAlloc  *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
13618    TRC2(rgSCHCmnUlAdd2UeLst);
13619    if (ulAllocInfo->reqLnk.node == NULLP)
13620    {
13621       cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
13622       ulAllocInfo->reqLnk.node = (PTR)ue;
13623    }
13624    RETVOID;
13625 }
13626
13627 /**
13628  * @brief
13629  *
13630  * @details
13631  *
13632  *     Function: rgSCHCmnAllocUlRb
13633  *     Purpose:  To do RB allocations for uplink
13634  *
13635  *     Invoked by: Common Scheduler
13636  *
13637  *  @param[in]  RgSchCellCb           *cell
13638  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
13639  *  @return  Void
13640  **/
13641 #ifdef ANSI
13642 PUBLIC Void rgSCHCmnAllocUlRb
13643 (
13644 RgSchCellCb           *cell,
13645 RgSchCmnUlRbAllocInfo *allocInfo
13646 )
13647 #else
13648 PUBLIC Void rgSCHCmnAllocUlRb(cell, allocInfo)
13649 RgSchCellCb           *cell;
13650 RgSchCmnUlRbAllocInfo *allocInfo;
13651 #endif
13652 {
13653    RgSchUlSf         *sf = allocInfo->sf;
13654    TRC2(rgSCHCmnAllocUlRb);
13655
13656    /* Schedule for new transmissions */
13657    rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
13658          &allocInfo->ueLst, &allocInfo->schdUeLst,
13659          &allocInfo->nonSchdUeLst, (Bool)TRUE);
13660    RETVOID;
13661 }
13662
13663 /***********************************************************
13664  *
13665  *     Func : rgSCHCmnUlRbAllocForLst
13666  *
13667  *     Desc : Allocate for a list in cmn rb alloc information passed
13668  *            in a subframe.
13669  *
13670  *     Ret  :
13671  *
13672  *     Notes:
13673  *
13674  *     File :
13675  *
13676  **********************************************************/
13677 #ifdef ANSI
13678 PRIVATE Void rgSCHCmnUlRbAllocForLst
13679 (
13680 RgSchCellCb           *cell,
13681 RgSchUlSf             *sf,
13682 U32                   count,
13683 CmLListCp             *reqLst,
13684 CmLListCp             *schdLst,
13685 CmLListCp             *nonSchdLst,
13686 Bool                  isNewTx
13687 )
13688 #else
13689 PRIVATE Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
13690                                      nonSchdLst, isNewTx)
13691 RgSchCellCb           *cell;
13692 RgSchUlSf             *sf;
13693 U32                   count;
13694 CmLListCp             *reqLst;
13695 CmLListCp             *schdLst;
13696 CmLListCp             *nonSchdLst;
13697 Bool                  isNewTx;
13698 #endif
13699 {
13700    CmLList          *lnk;
13701    RgSchUlHole      *hole;
13702 #ifdef LTE_L2_MEAS
13703 #ifdef LTE_TDD
13704    U8               k;
13705    CmLteTimingInfo  timeInfo;
13706 #endif    
13707 #endif    
13708    TRC2(rgSCHCmnUlRbAllocForLst);
13709
13710    if(schdLst->count == 0)
13711    {
13712       cmLListInit(schdLst);
13713    }
13714
13715    cmLListInit(nonSchdLst);
13716 #ifdef LTE_L2_MEAS
13717    if(isNewTx == TRUE)
13718    {
13719       cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (U8) count;
13720 #ifdef LTE_TDD
13721       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, timeInfo, TFU_ULCNTRL_DLDELTA);
13722       k = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][timeInfo.subframe];
13723       RG_SCH_ADD_TO_CRNT_TIME(timeInfo,
13724           cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo, k);
13725 #else
13726       RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime,cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.timingInfo,
13727                             (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
13728 #endif
13729    }
13730 #endif
13731
13732    for (lnk = reqLst->first; count; lnk = lnk->next, --count)
13733    {
13734       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13735       RgSchCmnUlUe          *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
13736       S16                   ret;
13737       U8                    maxRb;
13738
13739
13740       if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
13741       {
13742          break;
13743       }
13744
13745       ueUl->subbandShare = ueUl->subbandRequired;
13746       if(isNewTx == TRUE)
13747       {
13748          maxRb = RGSCH_MIN((ueUl->subbandRequired * MAX_5GTF_VRBG_SIZE), ue->ue5gtfCb.maxPrb);
13749       } 
13750       ret = rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole);
13751       if (ret == ROK)
13752       {
13753          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, schdLst);
13754          rgSCHCmnUlUeFillAllocInfo(cell, ue);
13755       }
13756       else
13757       {
13758          gUl5gtfRbAllocFail++;
13759 #if defined (TENB_STATS) && defined (RG_5GTF)
13760          cell->tenbStats->sch.ul5gtfRbAllocFail++;
13761 #endif
13762          rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13763          ue->isMsg4PdcchWithCrnti = FALSE;
13764          ue->isSrGrant = FALSE;
13765       }
13766 #ifdef LTE_L2_MEAS
13767       if(isNewTx == TRUE)
13768       {
13769          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13770          ulAllocInfo[count - 1].rnti   = ue->ueId;
13771          cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.
13772          ulAllocInfo[count - 1].numPrb = ue->ul.nPrb;
13773       }
13774 #endif
13775       ueUl->subbandShare = 0; /* This reset will take care of
13776                                   * all scheduler types */
13777    }
13778    for (; count; lnk = lnk->next, --count)
13779    {
13780       RgSchUeCb             *ue = (RgSchUeCb *)lnk->node;
13781       rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
13782       ue->isMsg4PdcchWithCrnti = FALSE;
13783    }
13784    RETVOID;
13785 }
13786
13787 #ifdef UNUSED_FUNC
13788 #ifdef TFU_UPGRADE
13789 /***********************************************************
13790  *
13791  *     Func : rgSCHCmnUlMdfyGrntForCqi
13792  *
13793  *     Desc : Modify UL Grant to consider presence of 
13794  *            CQI along with PUSCH Data.
13795  *
13796  *     Ret  :
13797  *
13798  *     Notes: 
13799  *          -  Scale down iTbs based on betaOffset and
13800  *             size of Acqi Size.
13801  *          -  Optionally attempt to increase numSb by 1
13802  *             if input payload size does not fit in due 
13803  *             to reduced tbSz as a result of iTbsNew.
13804  *
13805  *     File :
13806  *
13807  **********************************************************/
13808 #ifdef ANSI
13809 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi
13810 (
13811 RgSchCellCb  *cell,
13812 RgSchUeCb    *ue,
13813 U32          maxRb,
13814 U32          *numSb,
13815 U8           *iTbs,
13816 U32          hqSz,
13817 U32          stepDownItbs,
13818 U32          effTgt
13819 )
13820 #else
13821 PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
13822 RgSchCellCb  *cell;
13823 RgSchUeCb    *ue;
13824 U32          maxRb;
13825 U32          *numSb;
13826 U8           *iTbs;
13827 U32          hqSz;
13828 U32          stepDownItbs;
13829 U32          effTgt;
13830 #endif
13831 {
13832    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
13833    U32  nPrb;
13834    U32  totREs;
13835    U32  cqiRiREs;
13836    U32  hqREs;
13837    U32  remREsForPusch;
13838    U32  bitsPerRe;
13839    U32  tbSz;
13840    U32  betaOffVal = ue->ul.betaOffstVal;
13841    U32  cqiRiRptSz = ue->ul.cqiRiSz;
13842    U32  betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
13843    U32  resNumSb = *numSb;
13844    U32  puschEff = 1000;
13845    U8   modOdr;
13846    U8   iMcs;
13847    Bool mdfyiTbsFlg = FALSE;
13848    U8   resiTbs = *iTbs;
13849
13850    TRC2(rgSCHCmnUlMdfyGrntForCqi)
13851
13852    
13853    do
13854    {
13855       iMcs  = rgSCHCmnUlGetIMcsFrmITbs(resiTbs, RG_SCH_CMN_GET_UE_CTGY(ue));
13856       RG_SCH_UL_MCS_TO_MODODR(iMcs, modOdr);
13857       if (RG_SCH_CMN_GET_UE_CTGY(ue) != CM_LTE_UE_CAT_5)
13858       {
13859          modOdr = RGSCH_MIN(RGSCH_QM_QPSK, modOdr);
13860       }
13861       else
13862       {
13863          modOdr = RGSCH_MIN(RGSCH_QM_64QAM, modOdr);
13864       }
13865       nPrb = resNumSb * cellUl->sbSize;
13866       /* Restricting the minumum iTbs requried to modify to 10 */
13867       if ((nPrb >= maxRb) && (resiTbs <= 10))
13868       {
13869          /* Could not accomodate ACQI */
13870          RETVALUE(RFAILED);
13871       }
13872       totREs = nPrb * RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
13873       tbSz = rgTbSzTbl[0][resiTbs][nPrb-1];
13874       /*  totalREs/tbSz = num of bits perRE.  */
13875       cqiRiREs = (totREs * betaOffVal * cqiRiRptSz)/(1000 * tbSz); /* betaOffVal is represented 
13876                                                                    as parts per 1000 */
13877       hqREs = (totREs * betaOffHqVal * hqSz)/(1000 * tbSz);
13878       if ((cqiRiREs + hqREs) < totREs)
13879       {
13880          remREsForPusch = totREs - cqiRiREs - hqREs;
13881          bitsPerRe = (tbSz * 1000)/remREsForPusch; /* Multiplying by 1000 for Interger Oper */
13882          puschEff = bitsPerRe/modOdr;
13883       }
13884       if (puschEff < effTgt)
13885       {
13886           /* ensure resultant efficiency for PUSCH Data is within 0.93*/
13887           break;
13888       }
13889       else
13890       {
13891          /* Alternate between increasing SB or decreasing iTbs until eff is met */
13892          if (mdfyiTbsFlg == FALSE)
13893          {
13894             if (nPrb < maxRb)
13895             {
13896               resNumSb = resNumSb + 1;
13897             }
13898             mdfyiTbsFlg = TRUE;
13899          }
13900          else
13901          {
13902             if (resiTbs > 10)
13903             {
13904                resiTbs-= stepDownItbs;
13905             }
13906             mdfyiTbsFlg = FALSE;
13907          }
13908       }
13909    }while (1); /* Loop breaks if efficency is met 
13910                   or returns RFAILED if not able to meet the efficiency */
13911               
13912    *numSb = resNumSb;
13913    *iTbs = resiTbs;
13914
13915    RETVALUE(ROK);
13916 }
13917 #endif
13918 #endif
13919 /***********************************************************
13920  *
13921  *     Func : rgSCHCmnUlRbAllocForUe
13922  *
13923  *     Desc : Do uplink RB allocation for an UE.
13924  *
13925  *     Ret  :
13926  *
13927  *     Notes: Note that as of now, for retx, maxRb
13928  *            is not considered. Alternatives, such
13929  *            as dropping retx if it crosses maxRb
13930  *            could be considered.
13931  *
13932  *     File :
13933  *
13934  **********************************************************/
13935 #ifdef ANSI
13936 PRIVATE S16 rgSCHCmnUlRbAllocForUe
13937 (
13938 RgSchCellCb           *cell,
13939 RgSchUlSf             *sf,
13940 RgSchUeCb             *ue,
13941 U8                    maxRb,
13942 RgSchUlHole           *hole
13943 )
13944 #else
13945 PRIVATE S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
13946 RgSchCellCb           *cell;
13947 RgSchUlSf             *sf;
13948 RgSchUeCb             *ue;
13949 U8                    maxRb;
13950 RgSchUlHole           *hole;
13951 #endif
13952 {
13953    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
13954    RgSchCmnUlUe    *ueUl    = RG_SCH_CMN_GET_UL_UE(ue, cell);
13955    RgSchUlAlloc     *alloc = NULLP;
13956    U32              nPrb = 0;
13957    U8               numVrbg;
13958    U8               iMcs;
13959    U8               iMcsCrnt;
13960 #ifndef RG_5GTF
13961    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
13962 #else
13963    RgSchUlHqProcCb  *proc = NULLP;
13964 #endif
13965    RgSchPdcch       *pdcch;
13966    U32              reqVrbg;
13967    U8               numVrbgTemp;
13968 #ifdef RG_5GTF
13969    TfuDciFormat     dciFrmt;
13970    U8               numLyr;
13971 #endif
13972
13973    TRC2(rgSCHCmnUlRbAllocForUe);
13974 #ifdef RG_5GTF
13975    rgSCHUhmGetAvlHqProc(cell, ue, &proc);
13976    if (proc == NULLP)
13977    {
13978       //printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
13979       RETVALUE(RFAILED);
13980    }
13981 #endif
13982
13983    if (ue->ue5gtfCb.rank == 2)
13984    {
13985       dciFrmt = TFU_DCI_FORMAT_A2;
13986       numLyr = 2;
13987    }
13988    else
13989    {
13990       dciFrmt = TFU_DCI_FORMAT_A1;
13991       numLyr = 1;
13992    }
13993    /* 5gtf TODO : To pass dci frmt to this function */
13994    pdcch = rgSCHCmnPdcchAllocCrntSf(cell, ue);
13995    if(pdcch == NULLP)
13996    {
13997       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId, 
13998          "rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
13999       RETVALUE(RFAILED);
14000    }
14001         gUl5gtfPdcchSchd++;
14002 #if defined (TENB_STATS) && defined (RG_5GTF)
14003    cell->tenbStats->sch.ul5gtfPdcchSchd++;
14004 #endif
14005
14006    //TODO_SID using configured prb as of now
14007    nPrb = ue->ue5gtfCb.maxPrb;
14008    reqVrbg = nPrb/MAX_5GTF_VRBG_SIZE;
14009    iMcs  = ue->ue5gtfCb.mcs; //gSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
14010    iMcsCrnt = iMcs;
14011    numVrbg = reqVrbg;
14012
14013    if((sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart > MAX_5GTF_VRBG)
14014          || (sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated > MAX_5GTF_VRBG))
14015    {
14016       printf("5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
14017             , sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated);
14018       int *p=NULLP;
14019       *p = 10;
14020    }
14021
14022    /*TODO_SID: Workaround for alloc. Currently alloc is ulsf based. To handle multiple beams, we need a different
14023      design. Now alloc are formed based on MAX_5GTF_UE_SCH macro. */
14024    numVrbgTemp = MAX_5GTF_VRBG/MAX_5GTF_UE_SCH;
14025    if(numVrbg)
14026    {
14027       alloc = rgSCHCmnUlSbAlloc(sf, numVrbgTemp,\
14028                                 hole);
14029    }
14030    if (alloc == NULLP)
14031    {
14032       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
14033          "rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
14034       rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
14035       RETVALUE(RFAILED);
14036    }
14037    gUl5gtfAllocAllocated++;
14038 #if defined (TENB_STATS) && defined (RG_5GTF)
14039    cell->tenbStats->sch.ul5gtfAllocAllocated++;
14040 #endif
14041    alloc->grnt.vrbgStart = sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart;
14042    alloc->grnt.numVrbg = numVrbg;
14043    alloc->grnt.numLyr = numLyr;
14044    alloc->grnt.dciFrmt = dciFrmt;
14045
14046    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart += numVrbg;
14047    sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated += numVrbg;
14048
14049    //rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
14050 #ifdef LTE_L2_MEAS
14051    sf->totPrb  += alloc->grnt.numRb;
14052    ue->ul.nPrb = alloc->grnt.numRb;
14053 #endif
14054    if (ue->csgMmbrSta != TRUE)
14055    {
14056       cellUl->ncsgPrbCnt += alloc->grnt.numRb;
14057    }
14058    cellUl->totPrbCnt += (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14059    alloc->pdcch = pdcch;
14060    alloc->grnt.iMcs = iMcs;
14061    alloc->grnt.iMcsCrnt = iMcsCrnt;
14062    alloc->grnt.hop = 0;
14063    /* Initial Num RBs support for UCI on PUSCH */
14064 #ifdef TFU_UPGRADE
14065    ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
14066 #endif
14067    alloc->forMsg3 = FALSE;
14068    //RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTb5gtfSzTbl[0], (iTbs)); 
14069
14070    //ueUl->alloc.allocdBytes = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
14071    /* TODO_SID Allocating based on configured MCS as of now.
14072          Currently for format A2. When doing multi grp per tti, need to update this. */
14073    ueUl->alloc.allocdBytes = (rgSch5gtfTbSzTbl[iMcs]/8) * ue->ue5gtfCb.rank;
14074
14075    alloc->grnt.datSz = ueUl->alloc.allocdBytes;
14076    //TODO_SID Need to check mod order.
14077    RG_SCH_CMN_TBS_TO_MODODR(iMcs, alloc->grnt.modOdr);
14078         //alloc->grnt.modOdr = 6;
14079    alloc->grnt.isRtx = FALSE;
14080
14081    alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
14082    alloc->grnt.SCID = 0;
14083    alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
14084    alloc->grnt.PMI = 0;
14085    alloc->grnt.uciOnxPUSCH = 0;
14086    alloc->grnt.hqProcId = proc->procId;
14087
14088    alloc->hqProc = proc;
14089    alloc->hqProc->ulSfIdx = cellUl->schdIdx;
14090    alloc->ue = ue;
14091    /*commenting to retain the rnti used for transmission SPS/c-rnti */
14092    alloc->rnti = ue->ueId;
14093    ueUl->alloc.alloc = alloc;
14094    /*rntiwari-Adding the debug for generating the graph.*/
14095    /* No grant attr recorded now */
14096    RETVALUE(ROK);
14097 }
14098
14099 /***********************************************************
14100  *
14101  *     Func : rgSCHCmnUlRbAllocAddUeToLst
14102  *
14103  *     Desc : Add UE to list (scheduled/non-scheduled list)
14104  *            for UL RB allocation information.
14105  *
14106  *     Ret  :
14107  *
14108  *     Notes:
14109  *
14110  *     File :
14111  *
14112  **********************************************************/
14113 #ifdef ANSI
14114 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst
14115 (
14116 RgSchCellCb           *cell,
14117 RgSchUeCb             *ue,
14118 CmLListCp             *lst
14119 )
14120 #else
14121 PUBLIC Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
14122 RgSchCellCb           *cell;
14123 RgSchUeCb             *ue;
14124 CmLListCp             *lst;
14125 #endif
14126 {
14127    RgSchCmnUlUe   *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
14128    TRC2(rgSCHCmnUlRbAllocAddUeToLst);
14129    UNUSED(cell);
14130
14131    gUl5gtfUeRbAllocDone++;
14132 #if defined (TENB_STATS) && defined (RG_5GTF)
14133    cell->tenbStats->sch.ul5gtfUeRbAllocDone++;
14134 #endif
14135    cmLListAdd2Tail(lst, &ueUl->alloc.schdLstLnk);
14136    ueUl->alloc.schdLstLnk.node = (PTR)ue;
14137 }
14138
14139
14140 /**
14141  * @brief This function Processes the Final Allocations
14142  *        made by the RB Allocator against the requested.
14143  *
14144  * @details
14145  *
14146  *     Function: rgSCHCmnUlAllocFnlz
14147  *     Purpose:  This function Processes the Final Allocations
14148  *               made by the RB Allocator against the requested.
14149  *
14150  *     Invoked by: Common Scheduler
14151  *
14152  *  @param[in]  RgSchCellCb           *cell
14153  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14154  *  @return  Void
14155  *
14156  **/
14157 #ifdef ANSI
14158 PRIVATE Void rgSCHCmnUlAllocFnlz
14159 (
14160 RgSchCellCb           *cell,
14161 RgSchCmnUlRbAllocInfo *allocInfo
14162 )
14163 #else
14164 PRIVATE Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
14165 RgSchCellCb           *cell;
14166 RgSchCmnUlRbAllocInfo *allocInfo;
14167 #endif
14168 {
14169    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
14170    TRC2(rgSCHCmnUlAllocFnlz);
14171
14172    /* call scheduler specific Finalization */
14173    cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
14174
14175    RETVOID;
14176 }
14177
14178 /**
14179  * @brief This function Processes the Final Allocations
14180  *        made by the RB Allocator against the requested.
14181  *
14182  * @details
14183  *
14184  *     Function: rgSCHCmnDlAllocFnlz
14185  *     Purpose:  This function Processes the Final Allocations
14186  *               made by the RB Allocator against the requested.
14187  *
14188  *     Invoked by: Common Scheduler
14189  *
14190  *  @param[in]  RgSchCellCb           *cell
14191  *  @return  Void
14192  *
14193  **/
14194 #ifdef ANSI
14195 PUBLIC Void rgSCHCmnDlAllocFnlz
14196 (
14197 RgSchCellCb           *cell
14198 )
14199 #else
14200 PUBLIC Void rgSCHCmnDlAllocFnlz(cell)
14201 RgSchCellCb           *cell;
14202 #endif
14203 {
14204    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14205    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo; 
14206
14207    TRC2(rgSCHCmnDlAllocFnlz);
14208
14209    rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
14210    rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
14211 #ifdef RGR_V1
14212    /* Added below functions for handling CCCH SDU transmission received
14213     * after
14214     *     * guard timer expiry*/
14215    rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo);
14216    rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo);
14217 #endif
14218    rgSCHCmnDlRaRspFnlz(cell, allocInfo);
14219       /* call scheduler specific Finalization */
14220    cellSch->apisDl->rgSCHDlAllocFnlz(cell, allocInfo);
14221
14222    /* Stack Crash problem for TRACE5 Changes. Added the return below */
14223    RETVOID;
14224
14225 }
14226
14227 #ifdef RG_UNUSED
14228 /**
14229  * @brief Update an uplink subframe.
14230  *
14231  * @details
14232  *
14233  *     Function : rgSCHCmnUlUpdSf
14234  *
14235  *     For each allocation
14236  *      - if no more tx needed
14237  *         - Release allocation
14238  *      - else
14239  *         - Perform retransmission
14240  *
14241  *  @param[in]  RgSchUlSf *sf
14242  *  @return  Void
14243  **/
14244 #ifdef ANSI
14245 PRIVATE Void rgSCHCmnUlUpdSf
14246 (
14247 RgSchCellCb           *cell,
14248 RgSchCmnUlRbAllocInfo *allocInfo,
14249 RgSchUlSf *sf
14250 )
14251 #else
14252 PRIVATE Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
14253 RgSchCellCb           *cell;
14254 RgSchCmnUlRbAllocInfo *allocInfo;
14255 RgSchUlSf *sf;
14256 #endif
14257 {
14258    CmLList        *lnk;
14259    TRC2(rgSCHCmnUlUpdSf);
14260
14261    while ((lnk = sf->allocs.first))
14262    {
14263       RgSchUlAlloc  *alloc = (RgSchUlAlloc *)lnk->node;
14264       lnk = lnk->next;
14265
14266       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
14267       {
14268       }
14269       else
14270       {
14271          /* If need to handle all retx together, run another loop separately */
14272          rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc);
14273       }
14274       rgSCHCmnUlRlsUlAlloc(cell, sf, alloc);
14275    }
14276
14277    /* By this time, all allocs would have been cleared and
14278     * SF is reset to be made ready for new allocations. */
14279    rgSCHCmnUlSfReset(cell, sf);
14280    /* In case there are timing problems due to msg3
14281     * allocations being done in advance, (which will
14282     * probably happen with the current FDD code that
14283     * handles 8 subframes) one solution
14284     * could be to hold the (recent) msg3 allocs in a separate
14285     * list, and then possibly add that to the actual
14286     * list later. So at this time while allocations are
14287     * traversed, the recent msg3 ones are not seen. Anytime after
14288     * this (a good time is when the usual allocations
14289     * are made), msg3 allocations could be transferred to the
14290     * normal list. Not doing this now as it is assumed
14291     * that incorporation of TDD shall take care of this.
14292     */
14293
14294
14295    RETVOID;
14296 }
14297
14298 /**
14299  * @brief Handle uplink allocation for retransmission.
14300  *
14301  * @details
14302  *
14303  *     Function : rgSCHCmnUlHndlAllocRetx
14304  *
14305  *     Processing Steps:
14306  *     - Add to queue for retx.
14307  *     - Do not release here, release happends as part
14308  *       of the loop that calls this function.
14309  *
14310  *  @param[in]  RgSchCellCb           *cell
14311  *  @param[in]  RgSchCmnUlRbAllocInfo *allocInfo
14312  *  @param[in]  RgSchUlSf *sf
14313  *  @param[in]  RgSchUlAlloc  *alloc
14314  *  @return  Void
14315  **/
14316 #ifdef ANSI
14317 PRIVATE Void rgSCHCmnUlHndlAllocRetx
14318 (
14319 RgSchCellCb           *cell,
14320 RgSchCmnUlRbAllocInfo *allocInfo,
14321 RgSchUlSf     *sf,
14322 RgSchUlAlloc  *alloc
14323 )
14324 #else
14325 PRIVATE Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
14326 RgSchCellCb           *cell;
14327 RgSchCmnUlRbAllocInfo *allocInfo;
14328 RgSchUlSf     *sf;
14329 RgSchUlAlloc  *alloc;
14330 #endif
14331 {
14332    U32            bytes;
14333    RgSchCmnUlUe   *ueUl;
14334    TRC2(rgSCHCmnUlHndlAllocRetx);
14335    bytes = \
14336       rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
14337                                      [alloc->grnt.numRb-1]/8;
14338    if (!alloc->forMsg3)
14339    {
14340       ueUl = RG_SCH_CMN_GET_UL_UE(alloc->ue);
14341       ueUl->alloc.reqBytes = bytes;
14342       rgSCHUhmRetx(alloc->hqProc);
14343       rgSCHCmnUlAdd2RetxUeLst(allocInfo, alloc->ue);
14344    }
14345    else
14346    {
14347       /* RACHO msg3 retx handling. Part of RACH procedure changes. */
14348       retxAlloc = rgSCHCmnUlGetUlAlloc(cell, sf, alloc->numSb);
14349       if (retxAlloc == NULLP)
14350       {
14351          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
14352                "rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
14353                alloc->rnti);
14354          RETVOID;
14355       }
14356       retxAlloc->grnt.iMcs = alloc->grnt.iMcs;
14357       retxAlloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl\
14358                                  [alloc->hqProc->rvIdx];
14359       retxAlloc->grnt.nDmrs    = 0;
14360       retxAlloc->grnt.hop      = 0;
14361       retxAlloc->grnt.delayBit = 0;
14362       retxAlloc->rnti          = alloc->rnti;
14363       retxAlloc->ue            = NULLP;
14364       retxAlloc->pdcch         = FALSE;
14365       retxAlloc->forMsg3       = TRUE;
14366       retxAlloc->raCb          = alloc->raCb;
14367       retxAlloc->hqProc        = alloc->hqProc;
14368       rgSCHUhmRetx(retxAlloc->hqProc);
14369    }
14370    RETVOID;
14371 }
14372 #endif
14373
14374 /**
14375  * @brief Uplink Scheduling Handler.
14376  *
14377  * @details
14378  *
14379  *     Function: rgSCHCmnUlAlloc
14380  *     Purpose:  This function Handles Uplink Scheduling.
14381  *
14382  *     Invoked by: Common Scheduler
14383  *
14384  *  @param[in]  RgSchCellCb *cell
14385  *  @return  Void
14386  **/
14387 /* ccpu00132653- The definition of this function made common for TDD and FDD*/
14388 #ifdef ANSI
14389 PRIVATE Void rgSCHCmnUlAlloc
14390 (
14391 RgSchCellCb  *cell
14392 )
14393 #else
14394 PRIVATE Void rgSCHCmnUlAlloc(cell)
14395 RgSchCellCb  *cell;
14396 #endif
14397 {
14398    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14399    RgSchCmnUlCell         *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
14400    RgSchCmnDlCell         *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
14401    RgSchCmnUlRbAllocInfo  allocInfo;
14402    RgSchCmnUlRbAllocInfo  *allocInfoRef = &allocInfo;
14403 #ifdef RG_5GTF
14404    U8 idx;
14405
14406 #endif
14407
14408    TRC2(rgSCHCmnUlAlloc);
14409
14410    /* Initializing RgSchCmnUlRbAllocInfo structure */
14411    rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
14412
14413    /* Get Uplink Subframe */
14414    allocInfoRef->sf = &cellUl->ulSfArr[cellUl->schdIdx];
14415 #ifdef LTE_L2_MEAS
14416    /* initializing the UL PRB count */
14417    allocInfoRef->sf->totPrb = 0;
14418 #endif
14419
14420 #ifdef LTEMAC_SPS
14421    rgSCHCmnSpsUlTti(cell, allocInfoRef);
14422 #endif
14423
14424    if(*allocInfoRef->sf->allocCountRef == 0)
14425    {            
14426       RgSchUlHole     *hole;
14427
14428       if ((hole = rgSCHUtlUlHoleFirst(allocInfoRef->sf)) != NULLP)
14429       {
14430          /* Sanity check of holeDb */
14431          if (allocInfoRef->sf->holeDb->count == 1 && hole->start == 0) 
14432          {
14433             hole->num = cell->dynCfiCb.bwInfo[cellDl->currCfi].numSb;   
14434             /* Re-Initialize available subbands because of CFI change*/
14435             allocInfoRef->sf->availSubbands = cell->dynCfiCb.\
14436                                               bwInfo[cellDl->currCfi].numSb;
14437             /*Currently initializing 5gtf ulsf specific initialization here.
14438               need to do at proper place */
14439 #ifdef RG_5GTF
14440        allocInfoRef->sf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
14441        allocInfoRef->sf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
14442             for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
14443             {
14444                allocInfoRef->sf->sfBeamInfo[idx].totVrbgAllocated = 0;
14445                allocInfoRef->sf->sfBeamInfo[idx].totVrbgRequired = 0;
14446                allocInfoRef->sf->sfBeamInfo[idx].vrbgStart = 0;
14447             }    
14448 #endif
14449          }
14450          else
14451          {
14452             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
14453                   "Error! holeDb sanity check failed");
14454          }
14455       }
14456    }
14457
14458    /* Fix: Adaptive re-transmissions prioritised over other transmissions */
14459    /* perform adaptive retransmissions */
14460    rgSCHCmnUlSfReTxAllocs(cell, allocInfoRef->sf);
14461
14462         g5gtfTtiCnt++;
14463
14464    /* Fix: syed Adaptive Msg3 Retx crash. Release all
14465     Harq processes for which adap Retx failed, to avoid 
14466     blocking. This step should be done before New TX 
14467     scheduling to make hqProc available. Right now we
14468     dont check if proc is in adap Retx list for considering
14469     it to be available. But now with this release that 
14470     functionality would be correct. */
14471 #ifndef RG_5GTF
14472    rgSCHCmnUlSfRlsRetxProcs(cell, allocInfoRef->sf);  
14473 #endif
14474
14475    /* Specific UL scheduler to perform UE scheduling */
14476    cellSch->apisUl->rgSCHUlSched(cell, allocInfoRef);
14477
14478    /* Call UL RB allocator module */
14479    rgSCHCmnAllocUlRb(cell, allocInfoRef);
14480
14481    /* Do group power control for PUSCH */
14482    rgSCHCmnGrpPwrCntrlPusch(cell, allocInfoRef->sf);
14483
14484    cell->sc.apis->rgSCHDrxStrtInActvTmrInUl(cell);
14485
14486    rgSCHCmnUlAllocFnlz(cell, allocInfoRef);
14487         if(5000 == g5gtfTtiCnt)
14488         {
14489       ul5gtfsidDlAlreadyMarkUl = 0;
14490                 ul5gtfsidDlSchdPass = 0;
14491                 ul5gtfsidUlMarkUl = 0;
14492       ul5gtfTotSchdCnt = 0;
14493                 g5gtfTtiCnt = 0;
14494         }
14495
14496    RETVOID;
14497 }
14498
14499 /**
14500  * @brief send Subframe Allocations.
14501  *
14502  * @details
14503  *
14504  *     Function: rgSCHCmnSndCnsldtInfo
14505  *     Purpose:  Send the scheduled
14506  *     allocations to MAC for StaInd generation to Higher layers and
14507  *     for MUXing. PST's RgInfSfAlloc to MAC instance.
14508  *
14509  *     Invoked by: Common Scheduler
14510  *
14511  *  @param[in]  RgSchCellCb *cell
14512  *  @return  Void
14513  **/
14514 #ifdef ANSI
14515 PUBLIC Void rgSCHCmnSndCnsldtInfo
14516 (
14517 RgSchCellCb  *cell
14518 )
14519 #else
14520 PUBLIC Void rgSCHCmnSndCnsldtInfo(cell)
14521 RgSchCellCb  *cell;
14522 #endif
14523 {
14524    RgInfSfAlloc           *subfrmAlloc;
14525    Pst                    pst;
14526    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
14527
14528    TRC2(rgSCHCmnSndCnsldtInfo);
14529
14530    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14531
14532    /* Send the allocations to MAC for MUXing */
14533    rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
14534    subfrmAlloc->cellId = cell->cellId;
14535    /* Populate the List of UEs needing PDB-based Flow control */
14536    cellSch->apisDl->rgSCHDlFillFlwCtrlInfo(cell, subfrmAlloc);
14537 #ifdef LTE_L2_MEAS
14538    if((subfrmAlloc->rarInfo.numRaRntis) ||
14539 #ifdef EMTC_ENABLE
14540       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14541       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14542       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14543 #endif
14544       (subfrmAlloc->ueInfo.numUes)      ||
14545       (subfrmAlloc->cmnLcInfo.bitMask)  ||
14546          (subfrmAlloc->ulUeInfo.numUes)    ||
14547          (subfrmAlloc->flowCntrlInfo.numUes))
14548 #else
14549    if((subfrmAlloc->rarInfo.numRaRntis) ||
14550 #ifdef EMTC_ENABLE
14551       (subfrmAlloc->emtcInfo.rarInfo.numRaRntis) ||
14552       (subfrmAlloc->emtcInfo.cmnLcInfo.bitMask)  ||
14553       (subfrmAlloc->emtcInfo.ueInfo.numUes) ||
14554 #endif
14555       (subfrmAlloc->ueInfo.numUes)      ||
14556             (subfrmAlloc->cmnLcInfo.bitMask)  ||
14557             (subfrmAlloc->flowCntrlInfo.numUes))
14558 #endif
14559    {
14560       RgSchMacSfAlloc(&pst, subfrmAlloc);
14561    }
14562 #ifndef LTE_TDD
14563    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_NUM_SUB_FRAMES;
14564 #else
14565    cell->crntSfIdx  = (cell->crntSfIdx + 1) % RGSCH_SF_ALLOC_SIZE;
14566 #endif
14567    
14568    RETVOID;
14569 }
14570 /**
14571  * @brief Consolidate Subframe Allocations.
14572  *
14573  * @details
14574  *
14575  *     Function: rgSCHCmnCnsldtSfAlloc
14576  *     Purpose:  Consolidate Subframe Allocations.
14577  *
14578  *     Invoked by: Common Scheduler
14579  *
14580  *  @param[in]  RgSchCellCb *cell
14581  *  @return  Void
14582  **/
14583 #ifdef ANSI
14584 PUBLIC Void rgSCHCmnCnsldtSfAlloc
14585 (
14586 RgSchCellCb  *cell
14587 )
14588 #else
14589 PUBLIC Void rgSCHCmnCnsldtSfAlloc(cell)
14590 RgSchCellCb  *cell;
14591 #endif
14592 {
14593    RgInfSfAlloc           *subfrmAlloc;
14594    CmLteTimingInfo        frm;
14595    RgSchDlSf              *dlSf;
14596    CmLListCp              dlDrxInactvTmrLst;
14597    CmLListCp              dlInActvLst;
14598    CmLListCp              ulInActvLst;
14599    RgSchCmnCell           *cellSch = NULLP;
14600
14601    TRC2(rgSCHCmnCnsldtSfAlloc);
14602
14603    cmLListInit(&dlDrxInactvTmrLst);
14604    cmLListInit(&dlInActvLst);
14605    cmLListInit(&ulInActvLst);
14606
14607    subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
14608
14609    /* Get Downlink Subframe */
14610    frm   = cell->crntTime;
14611    RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
14612    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14613
14614    /* Fill the allocation Info */
14615    rgSCHUtlFillRgInfRarInfo(dlSf, subfrmAlloc, cell);
14616
14617   /* CA dev Start */
14618    rgSCHUtlFillRgInfUeInfo(dlSf, cell, &dlDrxInactvTmrLst, 
14619                            &dlInActvLst, &ulInActvLst);
14620 #ifdef RG_PFS_STATS
14621    cell->totalPrb += dlSf->bwAssigned;
14622 #endif
14623    /* Mark the following Ues inactive for UL*/
14624    cellSch = RG_SCH_CMN_GET_CELL(cell);
14625
14626    /* Calling Scheduler specific function with DRX inactive UE list*/
14627    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInActvLst);
14628    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInActvLst);
14629     
14630   /* CA dev End */
14631    /*re/start DRX inactivity timer for the UEs*/
14632    (Void)rgSCHDrxStrtInActvTmr(cell,&dlDrxInactvTmrLst,RG_SCH_DRX_DL);
14633
14634    RETVOID;
14635 }
14636
14637 /**
14638  * @brief Initialize the DL Allocation Information Structure.
14639  *
14640  * @details
14641  *
14642  *     Function: rgSCHCmnInitDlRbAllocInfo
14643  *     Purpose:  Initialize the DL Allocation Information Structure.
14644  *
14645  *     Invoked by: Common Scheduler
14646  *
14647  *  @param[out]  RgSchCmnDlRbAllocInfo  *allocInfo
14648  *  @return  Void
14649  **/
14650 #ifdef ANSI
14651 PRIVATE Void rgSCHCmnInitDlRbAllocInfo
14652 (
14653 RgSchCmnDlRbAllocInfo  *allocInfo
14654 )
14655 #else
14656 PRIVATE Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
14657 RgSchCmnDlRbAllocInfo  *allocInfo;
14658 #endif
14659 {
14660    TRC2(rgSCHCmnInitDlRbAllocInfo);
14661    cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14662    cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
14663    cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
14664          RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
14665
14666    allocInfo->msg4Alloc.msg4DlSf = NULLP;
14667    cmLListInit(&allocInfo->msg4Alloc.msg4TxLst);
14668    cmLListInit(&allocInfo->msg4Alloc.msg4RetxLst);
14669    cmLListInit(&allocInfo->msg4Alloc.schdMsg4TxLst);
14670    cmLListInit(&allocInfo->msg4Alloc.schdMsg4RetxLst);
14671    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4TxLst);
14672    cmLListInit(&allocInfo->msg4Alloc.nonSchdMsg4RetxLst);
14673 #ifdef RGR_V1
14674    allocInfo->ccchSduAlloc.ccchSduDlSf = NULLP;
14675    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduTxLst);
14676    cmLListInit(&allocInfo->ccchSduAlloc.ccchSduRetxLst);
14677    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduTxLst);
14678    cmLListInit(&allocInfo->ccchSduAlloc.schdCcchSduRetxLst);
14679    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduTxLst);
14680    cmLListInit(&allocInfo->ccchSduAlloc.nonSchdCcchSduRetxLst);
14681 #endif
14682
14683    allocInfo->dedAlloc.dedDlSf = NULLP;
14684    cmLListInit(&allocInfo->dedAlloc.txHqPLst);
14685    cmLListInit(&allocInfo->dedAlloc.retxHqPLst);
14686    cmLListInit(&allocInfo->dedAlloc.schdTxHqPLst);
14687    cmLListInit(&allocInfo->dedAlloc.schdRetxHqPLst);
14688    cmLListInit(&allocInfo->dedAlloc.nonSchdTxHqPLst);
14689    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxHqPLst);
14690
14691    cmLListInit(&allocInfo->dedAlloc.txRetxHqPLst);
14692    cmLListInit(&allocInfo->dedAlloc.schdTxRetxHqPLst);
14693    cmLListInit(&allocInfo->dedAlloc.nonSchdTxRetxHqPLst);
14694 #ifdef LTEMAC_SPS
14695    cmLListInit(&allocInfo->dedAlloc.txSpsHqPLst);
14696    cmLListInit(&allocInfo->dedAlloc.retxSpsHqPLst);
14697    cmLListInit(&allocInfo->dedAlloc.schdTxSpsHqPLst);
14698    cmLListInit(&allocInfo->dedAlloc.schdRetxSpsHqPLst);
14699    cmLListInit(&allocInfo->dedAlloc.nonSchdTxSpsHqPLst);
14700    cmLListInit(&allocInfo->dedAlloc.nonSchdRetxSpsHqPLst);
14701 #endif
14702
14703 #ifdef LTE_ADV
14704    rgSCHLaaCmnInitDlRbAllocInfo (allocInfo);
14705 #endif
14706
14707    cmLListInit(&allocInfo->dedAlloc.errIndTxHqPLst);
14708    cmLListInit(&allocInfo->dedAlloc.schdErrIndTxHqPLst);
14709    cmLListInit(&allocInfo->dedAlloc.nonSchdErrIndTxHqPLst);
14710    RETVOID;
14711 }
14712
14713 /**
14714  * @brief Initialize the UL Allocation Information Structure.
14715  *
14716  * @details
14717  *
14718  *     Function: rgSCHCmnInitUlRbAllocInfo
14719  *     Purpose:  Initialize the UL Allocation Information Structure.
14720  *
14721  *     Invoked by: Common Scheduler
14722  *
14723  *  @param[out]  RgSchCmnUlRbAllocInfo  *allocInfo
14724  *  @return  Void
14725  **/
14726 #ifdef ANSI
14727 PUBLIC Void rgSCHCmnInitUlRbAllocInfo
14728 (
14729 RgSchCmnUlRbAllocInfo  *allocInfo
14730 )
14731 #else
14732 PUBLIC Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
14733 RgSchCmnUlRbAllocInfo  *allocInfo;
14734 #endif
14735 {
14736    TRC2(rgSCHCmnInitUlRbAllocInfo);
14737    allocInfo->sf = NULLP;
14738    cmLListInit(&allocInfo->contResLst);
14739    cmLListInit(&allocInfo->schdContResLst);
14740    cmLListInit(&allocInfo->nonSchdContResLst);
14741    cmLListInit(&allocInfo->ueLst);
14742    cmLListInit(&allocInfo->schdUeLst);
14743    cmLListInit(&allocInfo->nonSchdUeLst);
14744
14745    RETVOID;
14746 }
14747
14748 /**
14749  * @brief Scheduling for PUCCH group power control.
14750  *
14751  * @details
14752  *
14753  *     Function: rgSCHCmnGrpPwrCntrlPucch
14754  *     Purpose: This function does group power control for PUCCH
14755  *     corresponding to the subframe for which DL UE allocations
14756  *     have happended.
14757  *
14758  *     Invoked by: Common Scheduler
14759  *
14760  *  @param[in]  RgSchCellCb *cell
14761  *  @return  Void
14762  **/
14763 #ifdef ANSI
14764 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch
14765 (
14766 RgSchCellCb            *cell,
14767 RgSchDlSf              *dlSf
14768 )
14769 #else
14770 PRIVATE Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
14771 RgSchCellCb            *cell;
14772 RgSchDlSf              *dlSf;
14773 #endif
14774 {
14775    TRC2(rgSCHCmnGrpPwrCntrlPucch);
14776
14777    rgSCHPwrGrpCntrlPucch(cell, dlSf);
14778
14779    RETVOID;
14780 }
14781
14782 /**
14783  * @brief Scheduling for PUSCH group power control.
14784  *
14785  * @details
14786  *
14787  *     Function: rgSCHCmnGrpPwrCntrlPusch
14788  *     Purpose: This function does group power control, for
14789  *     the subframe for which UL allocation has (just) happened.
14790  *
14791  *     Invoked by: Common Scheduler
14792  *
14793  *  @param[in]  RgSchCellCb *cell
14794  *  @param[in]  RgSchUlSf   *ulSf
14795  *  @return  Void
14796  **/
14797 #ifdef ANSI
14798 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch
14799 (
14800 RgSchCellCb            *cell,
14801 RgSchUlSf              *ulSf
14802 )
14803 #else
14804 PRIVATE Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
14805 RgSchCellCb            *cell;
14806 RgSchUlSf              *ulSf;
14807 #endif
14808 {
14809    /*removed unused variable *cellSch*/
14810    CmLteTimingInfo        frm;
14811    RgSchDlSf              *dlSf;
14812
14813    TRC2(rgSCHCmnGrpPwrCntrlPusch);
14814
14815    /* Got to pass DL SF corresponding to UL SF, so get that first.
14816     * There is no easy way of getting dlSf by having the RgSchUlSf*,
14817     * so use the UL delta from current time to get the DL SF. */
14818    frm   = cell->crntTime;
14819
14820 #ifdef EMTC_ENABLE
14821    if(cell->emtcEnable == TRUE)
14822    {
14823       RGSCH_INCR_SUB_FRAME_EMTC(frm, TFU_DLCNTRL_DLDELTA);
14824    }
14825    else
14826 #endif
14827    {
14828       RGSCH_INCR_SUB_FRAME(frm, TFU_DLCNTRL_DLDELTA);
14829    }
14830    /* Del filling of dl.time */
14831    dlSf = rgSCHUtlSubFrmGet(cell, frm);
14832
14833    rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf);
14834
14835    RETVOID;
14836 }
14837
14838 /* Fix: syed align multiple UEs to refresh at same time */
14839 /***********************************************************
14840  *
14841  *     Func : rgSCHCmnApplyUeRefresh 
14842  *
14843  *     Desc : Apply UE refresh in CMN and Specific 
14844  *     schedulers. Data rates and corresponding 
14845  *     scratchpad variables are updated.
14846  *
14847  *     Ret  :
14848  *
14849  *     Notes:
14850  *
14851  *     File :
14852  *
14853  **********************************************************/
14854 #ifdef ANSI
14855 PRIVATE S16 rgSCHCmnApplyUeRefresh 
14856 (
14857 RgSchCellCb     *cell,
14858 RgSchUeCb       *ue
14859 )
14860 #else
14861 PRIVATE S16 rgSCHCmnApplyUeRefresh(cell, ue)
14862 RgSchCellCb     *cell;
14863 RgSchUeCb       *ue;
14864 #endif
14865 {
14866    RgSchCmnCell    *cellSch     = RG_SCH_CMN_GET_CELL(cell);
14867    U32             effGbrBsr    = 0;
14868    U32             effNonGbrBsr = 0;
14869    U32             lcgId;
14870
14871    TRC2(rgSCHCmnApplyUeRefresh);
14872
14873    /* Reset the refresh cycle variableCAP */
14874    ue->ul.effAmbr = ue->ul.cfgdAmbr;
14875
14876    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
14877    {
14878       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
14879       {
14880          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
14881
14882          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
14883          {
14884             cmnLcg->effGbr = cmnLcg->cfgdGbr;
14885             cmnLcg->effDeltaMbr = cmnLcg->deltaMbr;
14886             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
14887             /* Considering GBR LCG will be prioritised by UE */
14888             effGbrBsr += cmnLcg->bs;
14889          }/* Else no remaing BS so nonLcg0 will be updated when BSR will be received */
14890          else
14891          {
14892             effNonGbrBsr += cmnLcg->reportedBs;
14893             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
14894          }
14895       }
14896    }
14897    effNonGbrBsr = RGSCH_MIN(effNonGbrBsr,ue->ul.effAmbr);
14898    ue->ul.nonGbrLcgBs = effNonGbrBsr;
14899
14900    ue->ul.nonLcg0Bs = effGbrBsr + effNonGbrBsr;
14901    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
14902                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
14903
14904
14905    /* call scheduler specific event handlers
14906     * for refresh timer expiry */
14907    cellSch->apisUl->rgSCHUlUeRefresh(cell, ue);
14908    cellSch->apisDl->rgSCHDlUeRefresh(cell, ue);
14909
14910    RETVALUE(ROK);
14911 }
14912
14913 /***********************************************************
14914  *
14915  *     Func : rgSCHCmnTmrExpiry
14916  *
14917  *     Desc : Adds an UE to refresh queue, so that the UE is
14918  *            periodically triggered to refresh it's GBR and
14919  *            AMBR values.
14920  *
14921  *     Ret  :
14922  *
14923  *     Notes:
14924  *
14925  *     File :
14926  *
14927  **********************************************************/
14928 #ifdef ANSI
14929 PRIVATE S16 rgSCHCmnTmrExpiry
14930 (
14931 PTR cb,               /* Pointer to timer control block */
14932 S16 tmrEvnt           /* Timer Event */
14933 )
14934 #else
14935 PRIVATE S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
14936 PTR cb;               /* Pointer to timer control block */
14937 S16 tmrEvnt;           /* Timer Event */
14938 #endif
14939 {
14940    RgSchUeCb       *ue = (RgSchUeCb *)cb;
14941    RgSchCellCb     *cell = ue->cell;
14942 #if (ERRCLASS & ERRCLS_DEBUG)
14943 #endif
14944
14945    TRC2(rgSCHCmnTmrExpiry);
14946
14947 #if (ERRCLASS & ERRCLS_DEBUG)
14948    if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
14949    {
14950       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
14951          "timer event CRNTI:%d",ue->ueId);
14952       RETVALUE(RFAILED);
14953    }
14954 #else
14955    UNUSED(tmrEvnt);
14956 #endif
14957
14958    rgSCHCmnApplyUeRefresh(cell, ue);
14959
14960    rgSCHCmnAddUeToRefreshQ(cell, ue, RG_SCH_CMN_REFRESH_TIME);
14961
14962    RETVALUE(ROK);
14963 }
14964
14965 /***********************************************************
14966  *
14967  *     Func : rgSCHCmnTmrProc
14968  *
14969  *     Desc : Timer entry point per cell. Timer
14970  *            processing is triggered at every frame boundary
14971  *            (every 10 ms).
14972  *
14973  *     Ret  :
14974  *
14975  *     Notes:
14976  *
14977  *     File :
14978  *
14979  **********************************************************/
14980 #ifdef ANSI
14981 PRIVATE S16 rgSCHCmnTmrProc
14982 (
14983 RgSchCellCb *cell
14984 )
14985 #else
14986 PRIVATE S16 rgSCHCmnTmrProc(cell)
14987 RgSchCellCb *cell;
14988 #endif
14989 {
14990    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
14991    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
14992    /* Moving the assignment of scheduler pointer
14993      to available scope for optimization */
14994    TRC2(rgSCHCmnTmrProc);
14995
14996    if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
14997    {
14998       /* Reset the counters periodically */
14999       if ((cell->crntTime.sfn % RG_SCH_CMN_CSG_REFRESH_TIME) == 0)
15000       {
15001          RG_SCH_RESET_HCSG_DL_PRB_CNTR(cmnDlCell);
15002          RG_SCH_RESET_HCSG_UL_PRB_CNTR(cmnUlCell);
15003       }
15004       if ((cell->crntTime.sfn % RG_SCH_CMN_OVRLDCTRL_REFRESH_TIME) == 0)
15005       {
15006
15007          cell->measurements.ulTpt =  ((cell->measurements.ulTpt * 95) + ( cell->measurements.ulBytesCnt * 5))/100;
15008          cell->measurements.dlTpt =  ((cell->measurements.dlTpt * 95) + ( cell->measurements.dlBytesCnt * 5))/100;
15009
15010          rgSCHUtlCpuOvrLdAdjItbsCap(cell);
15011          /* reset cell level tpt measurements for next cycle */
15012          cell->measurements.ulBytesCnt = 0;
15013          cell->measurements.dlBytesCnt = 0;
15014       }
15015       /* Comparing with Zero instead of % is being done for efficiency.
15016        * If Timer resolution changes then accordingly update the
15017        * macro RG_SCH_CMN_REFRESH_TIMERES */    
15018       RgSchCmnCell   *sched  = RG_SCH_CMN_GET_CELL(cell);
15019       cmPrcTmr(&sched->tmrTqCp, sched->tmrTq, (PFV)rgSCHCmnTmrExpiry);
15020    }
15021
15022    RETVALUE(ROK);
15023 }
15024
15025
15026 /***********************************************************
15027  *
15028  *     Func : rgSchCmnUpdCfiVal 
15029  *
15030  *     Desc : Update the CFI value if CFI switch was done 
15031  *
15032  *     Ret  :
15033  *
15034  *     Notes:
15035  *
15036  *     File :
15037  *
15038  **********************************************************/
15039 #ifdef ANSI
15040 PRIVATE Void rgSchCmnUpdCfiVal
15041 (
15042 RgSchCellCb     *cell,
15043 U8              delta
15044 )
15045 #else
15046 PRIVATE Void rgSchCmnUpdCfiVal(cell, delta)
15047 RgSchCellCb     *cell;
15048 U8              delta;
15049 #endif  
15050 {
15051    RgSchDlSf        *dlSf;
15052    CmLteTimingInfo  pdsch;
15053    RgSchCmnDlCell  *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell); 
15054    U8               dlIdx;
15055 #ifdef LTE_TDD
15056    U8               mPhich;
15057    RgSchDlSf        *tddSf;
15058    U8               idx;
15059    U8               splSfCfi = 0;
15060 #endif    
15061
15062    TRC2(rgSchCmnUpdCfiVal);
15063
15064    pdsch  = cell->crntTime;
15065    RGSCH_INCR_SUB_FRAME(pdsch, delta);
15066    dlSf = rgSCHUtlSubFrmGet(cell, pdsch);
15067    /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15068     *change happens in that SF then UL PDCCH allocation happens with old CFI
15069     *but CFI in control Req goes updated one since it was stored in the CELL
15070     */
15071    dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15072    if(cell->dynCfiCb.pdcchSfIdx != 0xFF) 
15073    {
15074 #ifdef LTE_TDD
15075       dlIdx = rgSCHUtlGetDlSfIdx(cell, &pdsch);
15076 #else
15077       dlIdx = (((pdsch.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (pdsch.slot % RGSCH_NUM_SUB_FRAMES));
15078       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15079 #endif  
15080       /* If current downlink subframe index is same as pdcch SF index,
15081        * perform the switching of CFI in this subframe */
15082       if(cell->dynCfiCb.pdcchSfIdx == dlIdx)
15083       {
15084          cellCmnDl->currCfi  = cellCmnDl->newCfi;
15085          cell->dynCfiCb.pdcchSfIdx = 0xFF;
15086
15087          /* Updating the nCce value based on the new CFI */
15088 #ifdef LTE_TDD
15089          splSfCfi = cellCmnDl->newCfi;
15090          for(idx = 0; idx < cell->numDlSubfrms; idx++)
15091          {   
15092             tddSf = cell->subFrms[idx];
15093
15094             mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][tddSf->sfNum];
15095
15096             if(tddSf->sfType == RG_SCH_SPL_SF_DATA)
15097             {
15098                RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, splSfCfi);
15099
15100                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][splSfCfi];
15101             }
15102             else
15103             {   
15104                tddSf->nCce = cell->dynCfiCb.cfi2NCceTbl[mPhich][cellCmnDl->currCfi];
15105             }
15106          }
15107          /* Setting the switch over window length based on config index.
15108           * During switch over period all the UL trnsmissions are Acked 
15109           * to UEs */
15110          cell->dynCfiCb.switchOvrWinLen = 
15111                rgSchCfiSwitchOvrWinLen[cell->ulDlCfgIdx];
15112 #else
15113          cell->nCce = cell->dynCfiCb.cfi2NCceTbl[0][cellCmnDl->currCfi];
15114          /* Fix for DCFI FLE issue: when DL delta is 1 and UL delta is 0 and CFI
15115           *change happens in that SF then UL PDCCH allocation happens with old CFI
15116           *but CFI in control Req goes updated one since it was stored in the CELL
15117           */
15118          dlSf->pdcchInfo.currCfi = cellCmnDl->currCfi;
15119          cell->dynCfiCb.switchOvrWinLen = rgSchCfiSwitchOvrWinLen[7];
15120 #endif
15121       }   
15122    }   
15123
15124    RETVOID;
15125 }
15126
15127 /***********************************************************
15128  *
15129  *     Func : rgSchCmnUpdtPdcchSfIdx 
15130  *
15131  *     Desc : Update the switch over window length
15132  *
15133  *     Ret  : void
15134  *
15135  *     Notes:
15136  *
15137  *     File :
15138  *
15139  **********************************************************/
15140 #ifdef LTE_TDD
15141 #ifdef ANSI
15142 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15143 (
15144 RgSchCellCb     *cell,
15145 U8              dlIdx,
15146 U8              sfNum
15147 )
15148 #else
15149 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
15150 RgSchCellCb     *cell;
15151 U8              dlIdx;
15152 U8              sfNum;
15153 #endif   
15154 #else
15155 #ifdef ANSI
15156 PRIVATE Void rgSchCmnUpdtPdcchSfIdx 
15157 (
15158 RgSchCellCb     *cell,
15159 U8              dlIdx
15160 )
15161 #else
15162 PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
15163 RgSchCellCb     *cell;
15164 U8              dlIdx;
15165 #endif    
15166 #endif
15167 {
15168    U8         idx;
15169
15170    TRC2(rgSchCmnUpdtPdcchSfIdx);
15171
15172    /* Resetting the parameters on CFI switching */
15173    cell->dynCfiCb.cceUsed = 0;
15174    cell->dynCfiCb.lowCceCnt = 0;
15175
15176    cell->dynCfiCb.cceFailSum = 0;
15177    cell->dynCfiCb.cceFailCnt = 0;
15178    cell->dynCfiCb.prevCceFailIdx = 0;
15179
15180    cell->dynCfiCb.switchOvrInProgress = TRUE;
15181
15182    for(idx = 0; idx < cell->dynCfiCb.numFailSamples; idx++)
15183    {
15184       cell->dynCfiCb.cceFailSamples[idx] = 0;
15185    }   
15186
15187    cell->dynCfiCb.ttiCnt = 0;
15188
15189    cell->dynCfiCb.cfiSwitches++;
15190    cfiSwitchCnt = cell->dynCfiCb.cfiSwitches;
15191
15192 #ifdef LTE_TDD 
15193    cell->dynCfiCb.pdcchSfIdx = (dlIdx + 
15194       rgSchTddPdcchSfIncTbl[cell->ulDlCfgIdx][sfNum]) % cell->numDlSubfrms;
15195 #else
15196    cell->dynCfiCb.pdcchSfIdx = (dlIdx + RG_SCH_CFI_APPLY_DELTA) % \
15197         RGSCH_NUM_DL_slotS;
15198 #endif
15199 }
15200
15201 /***********************************************************
15202  *
15203  *     Func : rgSchCmnUpdCfiDb 
15204  *
15205  *     Desc : Update the counters related to dynamic
15206  *            CFI feature in cellCb. 
15207  *
15208  *     Ret  :
15209  *
15210  *     Notes:
15211  *
15212  *     File :
15213  *
15214  **********************************************************/
15215 #ifdef ANSI
15216 PUBLIC Void rgSchCmnUpdCfiDb 
15217 (
15218 RgSchCellCb     *cell,
15219 U8              delta 
15220 )
15221 #else
15222 PUBLIC Void rgSchCmnUpdCfiDb(cell, delta)
15223 RgSchCellCb     *cell;
15224 U8              delta;
15225 #endif 
15226 {
15227    CmLteTimingInfo        frm;
15228    RgSchDlSf              *dlSf;
15229 #ifdef LTE_TDD
15230    U8                     mPhich;
15231    Bool                   isHiDci0; 
15232 #endif      
15233    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell); 
15234    U8                     nCceLowerCfi = 0;
15235    U8                     currCfi;
15236    U8                     cceFailIdx;
15237    U32                    totalCce;
15238    U8                     dlIdx;
15239    U16                    ttiMod;
15240
15241    TRC2(rgSchCmnUpdCfiDb);
15242
15243    /* Get Downlink Subframe */   
15244    frm   = cell->crntTime;
15245    RGSCH_INCR_SUB_FRAME(frm, delta);
15246
15247 #ifdef LTE_TDD
15248    dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
15249    dlSf = cell->subFrms[dlIdx];
15250    isHiDci0 = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15251 #else
15252    /* Changing the idexing
15253       so that proper subframe is selected */
15254    dlIdx = (((frm.sfn & 1) * RGSCH_NUM_SUB_FRAMES) + (frm.slot % RGSCH_NUM_SUB_FRAMES));
15255    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
15256    dlSf = cell->subFrms[dlIdx];
15257 #endif 
15258
15259    currCfi = cellSch->dl.currCfi;
15260
15261    if(!cell->dynCfiCb.switchOvrInProgress)
15262    {   
15263       do{
15264          if(!cell->dynCfiCb.isDynCfiEnb)
15265          {
15266             if(currCfi != cellSch->cfiCfg.cfi)
15267             {
15268                if(currCfi < cellSch->cfiCfg.cfi)
15269                {
15270                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15271                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15272                }
15273                else
15274                {
15275                   RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15276                   cfiDecr = cell->dynCfiCb.cfiDecr;
15277                }
15278             }
15279             break;
15280          }
15281
15282 #ifdef LTE_TDD         
15283          /* Setting ttiMod to 0 for ttiCnt > 1000 in case if this 
15284           * function was not called in UL subframe*/
15285          if(cell->dynCfiCb.ttiCnt > RGSCH_CFI_TTI_MON_INTRVL)
15286          {   
15287             ttiMod = 0;
15288          }
15289          else
15290 #endif
15291          {   
15292             ttiMod = cell->dynCfiCb.ttiCnt % RGSCH_CFI_TTI_MON_INTRVL;
15293          }
15294
15295          dlSf->dlUlBothCmplt++;
15296 #ifdef LTE_TDD      
15297          if((dlSf->dlUlBothCmplt == 2) || (!isHiDci0))
15298 #else
15299          if(dlSf->dlUlBothCmplt == 2)
15300 #endif         
15301          {
15302             /********************STEP UP CRITERIA********************/
15303             /* Updating the CCE failure count parameter */
15304             cell->dynCfiCb.cceFailCnt += dlSf->isCceFailure;
15305             cell->dynCfiCb.cceFailSum += dlSf->isCceFailure;
15306
15307             /* Check if cfi step up can be performed */
15308             if(currCfi < cell->dynCfiCb.maxCfi)
15309             {
15310                if(cell->dynCfiCb.cceFailSum >= cell->dynCfiCb.cfiStepUpTtiCnt) 
15311                {
15312                   RG_SCH_CFI_STEP_UP(cell, cellSch, currCfi)
15313                   cfiIncr = cell->dynCfiCb.cfiIncr;   
15314                   break;
15315                }
15316             } 
15317
15318             /********************STEP DOWN CRITERIA********************/
15319
15320             /* Updating the no. of CCE used in this dl subframe */
15321             cell->dynCfiCb.cceUsed += dlSf->cceCnt;
15322
15323             if(currCfi > RGSCH_MIN_CFI_VAL)
15324             {   
15325                /* calculating the number of CCE for next lower CFI */
15326 #ifdef LTE_TDD      
15327                mPhich = rgSchTddPhichMValTbl[cell->ulDlCfgIdx][dlSf->sfNum];
15328                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[mPhich][currCfi-1];
15329 #else
15330                nCceLowerCfi = cell->dynCfiCb.cfi2NCceTbl[0][currCfi-1];
15331 #endif     
15332                if(dlSf->cceCnt < nCceLowerCfi)
15333                {
15334                   /* Updating the count of TTIs in which no. of CCEs
15335                    * used were less than the CCEs of next lower CFI */
15336                   cell->dynCfiCb.lowCceCnt++;
15337                }   
15338
15339                if(ttiMod == 0)
15340                {
15341                   totalCce = (nCceLowerCfi * cell->dynCfiCb.cfiStepDownTtiCnt * 
15342                         RGSCH_CFI_CCE_PERCNTG)/100;
15343
15344                   if((!cell->dynCfiCb.cceFailSum) && 
15345                         (cell->dynCfiCb.lowCceCnt >= 
15346                          cell->dynCfiCb.cfiStepDownTtiCnt) && 
15347                         (cell->dynCfiCb.cceUsed < totalCce))  
15348                   {
15349                      RG_SCH_CFI_STEP_DOWN(cell, cellSch, currCfi)
15350                      cfiDecr = cell->dynCfiCb.cfiDecr; 
15351                      break;
15352                   }
15353                }   
15354             }
15355
15356             cceFailIdx = ttiMod/cell->dynCfiCb.failSamplePrd;
15357
15358             if(cceFailIdx != cell->dynCfiCb.prevCceFailIdx)
15359             {   
15360                /* New sample period has started. Subtract the old count  
15361                 * from the new sample period */
15362                cell->dynCfiCb.cceFailSum -= cell->dynCfiCb.cceFailSamples[cceFailIdx];
15363
15364                /* Store the previous sample period data */
15365                cell->dynCfiCb.cceFailSamples[cell->dynCfiCb.prevCceFailIdx]
15366                   = cell->dynCfiCb.cceFailCnt;
15367
15368                cell->dynCfiCb.prevCceFailIdx = cceFailIdx;
15369
15370                /* Resetting the CCE failure count as zero for next sample period */
15371                cell->dynCfiCb.cceFailCnt = 0;  
15372             }
15373
15374             if(ttiMod == 0)
15375             {   
15376                /* Restting the parametrs after Monitoring Interval expired */
15377                cell->dynCfiCb.cceUsed = 0;
15378                cell->dynCfiCb.lowCceCnt = 0;
15379                cell->dynCfiCb.ttiCnt = 0;
15380             }
15381
15382             cell->dynCfiCb.ttiCnt++;
15383          }
15384       }while(0);
15385
15386       if(cellSch->dl.newCfi != cellSch->dl.currCfi)
15387       {
15388 #ifdef LTE_TDD      
15389          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, dlSf->sfNum);
15390 #else
15391          rgSchCmnUpdtPdcchSfIdx(cell, dlIdx);
15392 #endif      
15393       }  
15394    }
15395 }   
15396
15397 /**
15398  * @brief Dl Scheduler for Broadcast and Common channel scheduling.
15399  *
15400  * @details
15401  *
15402  *     Function: rgSCHCmnDlCommonChSch
15403  *     Purpose:  This function schedules DL Common channels for LTE. 
15404  *               Invoked by TTI processing in TOM. Scheduling is done for 
15405  *               BCCH, PCCH, Msg4, CCCH SDU, RAR in that order 
15406  *
15407  *     Invoked by: TOM (TTI processing)
15408  *
15409  *  @param[in]  RgSchCellCb *cell
15410  *  @return  Void
15411  **/
15412 #ifdef ANSI
15413 PUBLIC Void rgSCHCmnDlCommonChSch
15414 (
15415 RgSchCellCb  *cell
15416 )
15417 #else
15418 PUBLIC Void rgSCHCmnDlCommonChSch(cell)
15419 RgSchCellCb  *cell;
15420 #endif
15421 {
15422    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
15423
15424    TRC2(rgSCHCmnDlCommonChSch);
15425
15426    cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
15427    rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
15428
15429    /* handle Inactive UEs for DL */
15430    rgSCHCmnHdlDlInactUes(cell);
15431
15432    /* Send a Tick to Refresh Timer */
15433    rgSCHCmnTmrProc(cell);
15434
15435    if (cell->isDlDataAllwd && (cell->stopSiSch == FALSE)) 
15436    {
15437       rgSCHCmnInitRbAlloc(cell); 
15438       /* Perform DL scheduling of BCCH, PCCH */
15439       rgSCHCmnDlBcchPcchAlloc(cell);
15440    }
15441    else
15442    {
15443       if(cell->siCb.inWindow != 0)
15444       {
15445          cell->siCb.inWindow--;
15446       }
15447    }
15448    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
15449    {
15450       rgSCHCmnDlCcchRarAlloc(cell);
15451    }
15452    RETVOID;
15453 }
15454
15455 /**
15456  * @brief Scheduler invocation per TTI.
15457  *
15458  * @details
15459  *
15460  *     Function: rgSCHCmnUlSch
15461  *     Purpose:  This function implements UL scheduler alone. This is to
15462  *               be able to perform scheduling with more flexibility.
15463  *
15464  *     Invoked by: TOM (TTI processing)
15465  *
15466  *  @param[in]  RgSchCellCb *cell
15467  *  @return  Void
15468  **/
15469 #ifdef ANSI
15470 PUBLIC Void rgSCHCmnUlSch
15471 (
15472 RgSchCellCb  *cell
15473 )
15474 #else
15475 PUBLIC Void  rgSCHCmnUlSch(cell)
15476 RgSchCellCb  *cell;
15477 #endif
15478 {
15479    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
15480    
15481    TRC2(rgSCHCmnUlSch);
15482
15483 #ifdef LTE_ADV
15484    /* LAA_SCELL: */
15485    if(TRUE == rgSCHLaaSCellEnabled(cell))
15486    {
15487       RETVOID;   
15488    }
15489 #endif
15490    
15491    if(cellSch->ul.schdIdx != RGSCH_INVALID_INFO)
15492    {   
15493       rgSchCmnUpdCfiVal(cell, TFU_ULCNTRL_DLDELTA);
15494
15495       /* Handle Inactive UEs for UL */
15496       rgSCHCmnHdlUlInactUes(cell);
15497       /* Perform UL Scheduling EVERY TTI */
15498       rgSCHCmnUlAlloc(cell);
15499
15500       /* Calling function to update CFI parameters*/
15501       rgSchCmnUpdCfiDb(cell, TFU_ULCNTRL_DLDELTA);   
15502
15503       if(cell->dynCfiCb.switchOvrWinLen > 0)
15504       {
15505          /* Decrementing the switchover window length */
15506          cell->dynCfiCb.switchOvrWinLen--;
15507
15508          if(!cell->dynCfiCb.switchOvrWinLen)
15509          {   
15510             if(cell->dynCfiCb.dynCfiRecfgPend)
15511             {  
15512                /* Toggling the Dynamic CFI enabling */
15513                cell->dynCfiCb.isDynCfiEnb ^= 1;
15514                rgSCHDynCfiReCfg(cell, cell->dynCfiCb.isDynCfiEnb); 
15515                cell->dynCfiCb.dynCfiRecfgPend = FALSE;
15516             }   
15517             cell->dynCfiCb.switchOvrInProgress = FALSE;
15518          }
15519       }
15520    }
15521 #ifdef LTE_TDD
15522 #ifdef LTEMAC_SPS
15523    else
15524    {
15525       rgSCHCmnSpsUlTti(cell, NULLP); 
15526    }
15527 #endif
15528 #endif
15529
15530    RETVOID;
15531 }
15532
15533 \f
15534 /**
15535  * @brief This function updates the scheduler with service for an UE.
15536  *
15537  * @details
15538  *
15539  *     Function: rgSCHCmnDlDedBoUpd
15540  *     Purpose:  This function should be called whenever there is a
15541  *               change BO for a service.
15542  *
15543  *     Invoked by: BO and Scheduler
15544  *
15545  *  @param[in]  RgSchCellCb*  cell
15546  *  @param[in]  RgSchUeCb*    ue
15547  *  @param[in]  RgSchDlLcCb*  svc
15548  *  @return  Void
15549  *
15550  **/
15551 #ifdef ANSI
15552 PUBLIC Void rgSCHCmnDlDedBoUpd
15553 (
15554 RgSchCellCb                *cell,
15555 RgSchUeCb                  *ue,
15556 RgSchDlLcCb                *svc
15557 )
15558 #else
15559 PUBLIC Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
15560 RgSchCellCb                *cell;
15561 RgSchUeCb                  *ue;
15562 RgSchDlLcCb                *svc;
15563 #endif
15564 {
15565    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15566    TRC2(rgSCHCmnDlDedBoUpd);
15567
15568    /* RACHO : if UEs idle time exceeded and a BO update
15569     * is received, then add UE to the pdcch Order Q */
15570    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
15571    {
15572       RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue, cell);
15573       /* If PDCCH order is already triggered and we are waiting for
15574        * RACH from UE then do not add to PdcchOdrQ. */
15575       if (ueDl->rachInfo.rapIdLnk.node == NULLP)
15576       {
15577          rgSCHCmnDlAdd2PdcchOdrQ(cell, ue);
15578       }
15579    }
15580
15581 #ifdef LTEMAC_SPS
15582
15583    /* If SPS service, invoke SPS module */
15584    if (svc->dlLcSpsCfg.isSpsEnabled)
15585    {
15586       rgSCHCmnSpsDlDedBoUpd(cell, ue, svc);
15587       /* Note: Retrun from here, no update needed in other schedulers */
15588       RETVOID;
15589    }
15590 #endif
15591 #ifdef EMTC_ENABLE
15592    if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
15593    {
15594       cellSch->apisEmtcDl->rgSCHDlDedBoUpd(cell, ue, svc);
15595       //printf("rgSCHEMTCDlDedBoUpd\n");
15596    }
15597    else
15598 #endif
15599    {
15600       cellSch->apisDl->rgSCHDlDedBoUpd(cell, ue, svc);
15601    }
15602 #ifdef LTE_ADV
15603    if (ue->numSCells)
15604    {
15605       rgSCHSCellDlDedBoUpd(cell, ue, svc);
15606    }
15607 #endif
15608    RETVOID;
15609 }
15610
15611 \f
15612 /**
15613  * @brief Removes an UE from Cell's TA List.
15614  *
15615  * @details
15616  *
15617  *     Function: rgSCHCmnRmvFrmTaLst
15618  *     Purpose:  Removes an UE from Cell's TA List.
15619  *
15620  *     Invoked by: Specific Scheduler
15621  *
15622  *  @param[in]  RgSchCellCb*     cell
15623  *  @param[in]  RgSchUeCb*       ue
15624  *  @return  Void
15625  *
15626  **/
15627 #ifdef ANSI
15628 PUBLIC Void rgSCHCmnRmvFrmTaLst
15629 (
15630 RgSchCellCb                *cell,
15631 RgSchUeCb                  *ue
15632 )
15633 #else
15634 PUBLIC Void rgSCHCmnRmvFrmTaLst(cell, ue)
15635 RgSchCellCb                *cell;
15636 RgSchUeCb                  *ue;
15637 #endif
15638 {
15639    RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
15640    TRC2(rgSCHCmnRmvFrmTaLst);
15641
15642 #ifdef EMTC_ENABLE
15643    if(cell->emtcEnable && ue->isEmtcUe)
15644    {
15645       rgSCHEmtcRmvFrmTaLst(cellCmnDl,ue);
15646    }
15647    else
15648 #endif
15649    {
15650       cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
15651       ue->dlTaLnk.node = (PTR)NULLP;
15652    }
15653    RETVOID;
15654 }
15655
15656 /* Fix: syed Remove the msg4Proc from cell
15657  * msg4Retx Queue. I have used CMN scheduler function
15658  * directly. Please define a new API and call this
15659  * function through that. */        
15660 \f
15661 /**
15662  * @brief This function removes MSG4 HARQ process from cell RETX Queues.
15663  *
15664  * @details
15665  *
15666  *     Function: rgSCHCmnDlMsg4ProcRmvFrmRetx
15667  *     Purpose:  This function removes MSG4 HARQ process from cell RETX Queues.
15668  *
15669  *     Invoked by: UE/RACB deletion. 
15670  *
15671  *  @param[in]  RgSchCellCb*     cell
15672  *  @param[in]  RgSchDlHqProc*   hqP
15673  *  @return  Void
15674  *
15675  **/
15676 #ifdef ANSI
15677 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx 
15678 (
15679 RgSchCellCb                *cell,
15680 RgSchDlHqProcCb            *hqP
15681 )
15682 #else
15683 PUBLIC Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
15684 RgSchCellCb                *cell;
15685 RgSchDlHqProcCb            *hqP;
15686 #endif
15687 {
15688    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15689    TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
15690
15691    if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
15692    {
15693       if (hqP->hqE->msg4Proc == hqP)
15694       {
15695          cmLListDelFrm(&cellSch->dl.msg4RetxLst, \
15696                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15697          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15698       }
15699 #ifdef RGR_V1
15700       else if(hqP->hqE->ccchSduProc == hqP)
15701       {
15702          cmLListDelFrm(&cellSch->dl.ccchSduRetxLst,
15703                &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15704          hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
15705       }
15706 #endif
15707    }
15708    RETVOID;
15709 }
15710
15711 \f
15712 /**
15713  * @brief This function adds a HARQ process for retx.
15714  *
15715  * @details
15716  *
15717  *     Function: rgSCHCmnDlProcAddToRetx
15718  *     Purpose:  This function adds a HARQ process to retransmission
15719  *               queue. This may be performed when a HARQ ack is
15720  *               unsuccessful.
15721  *
15722  *     Invoked by: HARQ feedback processing
15723  *
15724  *  @param[in]  RgSchCellCb*     cell
15725  *  @param[in]  RgSchDlHqProc*   hqP
15726  *  @return  Void
15727  *
15728  **/
15729 #ifdef ANSI
15730 PUBLIC Void rgSCHCmnDlProcAddToRetx
15731 (
15732 RgSchCellCb                *cell,
15733 RgSchDlHqProcCb            *hqP
15734 )
15735 #else
15736 PUBLIC Void rgSCHCmnDlProcAddToRetx(cell, hqP)
15737 RgSchCellCb                *cell;
15738 RgSchDlHqProcCb            *hqP;
15739 #endif
15740 {
15741    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
15742    TRC2(rgSCHCmnDlProcAddToRetx);
15743
15744    if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
15745    {
15746       cmLListAdd2Tail(&cellSch->dl.msg4RetxLst, \
15747             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15748       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15749    }
15750 #ifdef RGR_V1
15751    else if(hqP->hqE->ccchSduProc == hqP)
15752    {
15753       /*If CCCH SDU being transmitted without cont res CE*/
15754       cmLListAdd2Tail(&cellSch->dl.ccchSduRetxLst,
15755             &hqP->tbInfo[0].ccchSchdInfo.retxLnk);
15756       hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)hqP;
15757    }
15758 #endif
15759    else
15760    {
15761 #ifdef LTEMAC_SPS
15762       if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
15763       {
15764          /* Invoke SPS module for SPS HARQ proc re-transmission handling */
15765          rgSCHCmnSpsDlProcAddToRetx(cell, hqP);
15766          RETVOID;
15767       }
15768 #endif /* LTEMAC_SPS */
15769 #ifdef EMTC_ENABLE      
15770       if((TRUE == cell->emtcEnable)
15771          && (TRUE == hqP->hqE->ue->isEmtcUe))
15772       {
15773          cellSch->apisEmtcDl->rgSCHDlProcAddToRetx(cell, hqP);
15774       }
15775       else
15776 #endif         
15777       {
15778          cellSch->apisDl->rgSCHDlProcAddToRetx(cell, hqP);
15779       }
15780    }
15781    RETVOID;
15782 }
15783
15784 \f
15785 /**
15786  * @brief This function performs RI validation and
15787  *        updates it to the ueCb.
15788  *
15789  * @details
15790  *
15791  *     Function: rgSCHCmnDlSetUeRi
15792  *     Purpose:  This function performs RI validation and
15793  *        updates it to the ueCb.
15794  *
15795  *     Invoked by: rgSCHCmnDlCqiInd
15796  *
15797  *  @param[in]  RgSchCellCb        *cell
15798  *  @param[in]  RgSchUeCb          *ue
15799  *  @param[in]  U8                 ri
15800  *  @param[in]  Bool               isPeriodic
15801  *  @return  Void
15802  *
15803  **/
15804 #ifdef ANSI
15805 PRIVATE Void rgSCHCmnDlSetUeRi
15806 (
15807 RgSchCellCb        *cell,
15808 RgSchUeCb          *ue,
15809 U8                 ri,
15810 Bool               isPer
15811 )
15812 #else
15813 PRIVATE Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
15814 RgSchCellCb        *cell;
15815 RgSchUeCb          *ue;
15816 U8                 ri;
15817 Bool               isPer;
15818 #endif
15819 {
15820    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15821    RgSchCmnUeInfo    *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
15822    TRC2(rgSCHCmnDlSetUeRi);
15823    
15824 #ifdef TFU_UPGRADE
15825    RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
15826    UNUSED(isPer);
15827 #endif
15828
15829
15830    /* FIX for RRC Reconfiguration issue */
15831    /* ccpu00140894- During Tx Mode transition RI report will not entertained for 
15832     * specific during which SCH expecting UE can complete TX mode transition*/
15833    if (ue->txModeTransCmplt == FALSE)
15834    {
15835       RETVOID;
15836    }
15837
15838    /* Restrict the Number of TX layers to cell->numTxAntPorts.
15839     * Protection from invalid RI values. */
15840    ri = RGSCH_MIN(ri, cell->numTxAntPorts);
15841    
15842    /* Special case of converting PMI to sane value when
15843     * there is a switch in RI from 1 to 2 and PMI reported 
15844     * for RI=1 is invalid for RI=2 */
15845    if ((cell->numTxAntPorts == 2) && (ue->mimoInfo.txMode == RGR_UE_TM_4))
15846    {
15847       if ((ri == 2) && ( ueDl->mimoInfo.ri == 1))
15848       {
15849          ueDl->mimoInfo.pmi = (ueDl->mimoInfo.pmi < 2)? 1:2;
15850       }
15851    }
15852
15853    /* Restrict the Number of TX layers according to the UE Category */
15854    ueDl->mimoInfo.ri = RGSCH_MIN(ri, rgUeCatTbl[ueSchCmn->ueCat].maxTxLyrs);
15855 #ifdef TENB_STATS
15856    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].riCnt[ueDl->mimoInfo.ri-1]++;
15857    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15858 #endif
15859
15860 #ifdef TENB_STATS
15861    ue->tenbStats->stats.nonPersistent.sch[0].riCnt[ueDl->mimoInfo.ri-1]++;
15862    cell->tenbStats->sch.riCnt[ueDl->mimoInfo.ri-1]++;
15863 #endif
15864
15865 #ifdef TFU_UPGRADE
15866    if (isPer)
15867    {
15868       /* If RI is from Periodic CQI report */
15869       cqiCb->perRiVal = ueDl->mimoInfo.ri;
15870       /* Reset at every Periodic RI Reception */ 
15871       cqiCb->invalidateCqi = FALSE;
15872    }
15873    else
15874    {
15875       /* If RI is from Aperiodic CQI report */
15876       if (cqiCb->perRiVal != ueDl->mimoInfo.ri)
15877       {
15878          /* if this aperRI is different from last reported
15879           * perRI then invalidate all CQI reports till next
15880           * perRI */
15881          cqiCb->invalidateCqi = TRUE;
15882       }
15883       else
15884       {
15885          cqiCb->invalidateCqi = FALSE;
15886       }
15887    }
15888 #endif   
15889
15890    if (ueDl->mimoInfo.ri > 1)
15891    {
15892       RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15893    }
15894    else if (ue->mimoInfo.txMode == RGR_UE_TM_3) /* ri == 1 */
15895    {
15896       RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
15897    }
15898
15899    RETVOID;
15900 }
15901
15902 \f
15903 /**
15904  * @brief This function performs PMI validation and
15905  *        updates it to the ueCb.
15906  *
15907  * @details
15908  *
15909  *     Function: rgSCHCmnDlSetUePmi
15910  *     Purpose:  This function performs PMI validation and
15911  *        updates it to the ueCb.
15912  *
15913  *     Invoked by: rgSCHCmnDlCqiInd
15914  *
15915  *  @param[in]  RgSchCellCb        *cell
15916  *  @param[in]  RgSchUeCb          *ue
15917  *  @param[in]  U8                 pmi
15918  *  @return  Void
15919  *
15920  **/
15921 #ifdef ANSI
15922 PRIVATE S16 rgSCHCmnDlSetUePmi
15923 (
15924 RgSchCellCb        *cell,
15925 RgSchUeCb          *ue,
15926 U8                 pmi
15927 )
15928 #else
15929 PRIVATE S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
15930 RgSchCellCb        *cell;
15931 RgSchUeCb          *ue;
15932 U8                 pmi;
15933 #endif
15934 {
15935    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
15936    TRC2(rgSCHCmnDlSetUePmi);
15937
15938    if (ue->txModeTransCmplt == FALSE)
15939    {
15940        RETVALUE(RFAILED);
15941    }
15942  
15943    if (cell->numTxAntPorts == 2)
15944    {
15945       if (pmi > 3)
15946       {
15947          RETVALUE(RFAILED);
15948       }
15949       if (ueDl->mimoInfo.ri == 2)
15950       {
15951          /*ccpu00118150 - MOD - changed pmi value validation from 0 to 2*/
15952          /* PMI 2 and 3 are invalid incase of 2 TxAnt and 2 Layered SM */
15953          if (pmi == 2 || pmi == 3)
15954          {
15955             RETVALUE(RFAILED);
15956          }
15957          ueDl->mimoInfo.pmi = pmi+1;
15958       }
15959       else
15960       {
15961          ueDl->mimoInfo.pmi = pmi;
15962       }
15963    }
15964    else if (cell->numTxAntPorts == 4)
15965    {
15966       if (pmi > 15)
15967       {
15968          RETVALUE(RFAILED);
15969       }
15970       ueDl->mimoInfo.pmi = pmi;
15971    }
15972    /* Reset the No PMI Flag in forceTD */
15973    RG_SCH_CMN_UNSET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_NO_PMI);
15974    RETVALUE(ROK);
15975 }
15976
15977 /**
15978  * @brief This function Updates the DL CQI on PUCCH for the UE.
15979  *
15980  * @details
15981  *
15982  *     Function: rgSCHCmnDlProcCqiMode10
15983  *
15984  *     This function updates the DL CQI on PUCCH for the UE.
15985  *
15986  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
15987  *
15988  *     Processing Steps:
15989  *
15990  *  @param[in] RgSchCellCb     *cell
15991  *  @param[in] RgSchUeCb       *ue
15992  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
15993  *  @return  S16
15994  *      -# ROK
15995  *      -# RFAILED
15996  **/
15997 #ifdef RGR_CQI_REPT
15998 #ifdef ANSI
15999 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
16000 (
16001  RgSchCellCb        *cell,
16002  RgSchUeCb          *ue,
16003  TfuDlCqiPucch      *pucchCqi,
16004  Bool               *isCqiAvail
16005  )
16006 #else
16007 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
16008  RgSchCellCb        *cell;
16009  RgSchUeCb          *ue;
16010  TfuDlCqiPucch      *pucchCqi;
16011  Bool               *isCqiAvail;
16012 #endif
16013 #else
16014 #ifdef ANSI
16015 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10
16016 (
16017  RgSchCellCb        *cell,
16018  RgSchUeCb          *ue,
16019  TfuDlCqiPucch      *pucchCqi
16020  )
16021 #else
16022 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
16023  RgSchCellCb        *cell;
16024  RgSchUeCb          *ue;
16025  TfuDlCqiPucch      *pucchCqi;
16026 #endif
16027 #endif
16028 {
16029    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16030    TRC2(rgSCHCmnDlProcCqiMode10);
16031
16032    if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
16033    {
16034       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16035       /* Checking whether the decoded CQI is a value between 1 and 15*/
16036       if((pucchCqi->u.mode10Info.u.cqi) && (pucchCqi->u.mode10Info.u.cqi
16037                < RG_SCH_CMN_MAX_CQI))
16038       {
16039          ueDl->cqiFlag = TRUE;
16040          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode10Info.u.cqi;
16041          ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16042          /* ccpu00117452 - MOD - Changed macro name from
16043             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16044 #ifdef RGR_CQI_REPT
16045          *isCqiAvail = TRUE;
16046 #endif
16047       }
16048       else
16049       {
16050          RETVOID;
16051       }
16052    }
16053    else if (pucchCqi->u.mode10Info.type == TFU_RPT_RI)
16054    {
16055       if ( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode10Info.u.ri) )
16056       {
16057          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode10Info.u.ri,
16058                            TRUE);
16059       }
16060       else
16061       {
16062          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16063             pucchCqi->u.mode10Info.u.ri,ue->ueId);
16064          RETVOID;
16065       }
16066    }
16067 }
16068
16069 /**
16070  * @brief This function Updates the DL CQI on PUCCH for the UE.
16071  *
16072  * @details
16073  *
16074  *     Function: rgSCHCmnDlProcCqiMode11
16075  *
16076  *     This function updates the DL CQI on PUCCH for the UE.
16077  *
16078  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16079  *
16080  *     Processing Steps:
16081  *       Process CQI MODE 11
16082  *  @param[in] RgSchCellCb     *cell
16083  *  @param[in] RgSchUeCb       *ue
16084  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16085  *  @return  S16
16086  *      -# ROK
16087  *      -# RFAILED
16088  **/
16089 #ifdef RGR_CQI_REPT
16090 #ifdef ANSI
16091 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16092 (
16093  RgSchCellCb        *cell,
16094  RgSchUeCb          *ue,
16095  TfuDlCqiPucch      *pucchCqi,
16096  Bool               *isCqiAvail,
16097  Bool               *is2ndCwCqiAvail
16098  )
16099 #else
16100 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16101  RgSchCellCb        *cell;
16102  RgSchUeCb          *ue;
16103  TfuDlCqiPucch      *pucchCqi;
16104  Bool               *isCqiAvail;
16105  Bool               *is2ndCwCqiAvail;
16106 #endif
16107 #else
16108 #ifdef ANSI
16109 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11
16110 (
16111  RgSchCellCb        *cell,
16112  RgSchUeCb          *ue,
16113  TfuDlCqiPucch      *pucchCqi
16114  )
16115 #else
16116 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
16117  RgSchCellCb        *cell;
16118  RgSchUeCb          *ue;
16119  TfuDlCqiPucch      *pucchCqi;
16120 #endif
16121 #endif
16122 {
16123    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16124    TRC2(rgSCHCmnDlProcCqiMode11);
16125
16126    if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
16127    {
16128       ue->mimoInfo.puschFdbkVld  = FALSE;
16129       /*ccpu00109787 - ADD - Check for non-zero CQI*/
16130       if((pucchCqi->u.mode11Info.u.cqi.cqi) &&
16131             (pucchCqi->u.mode11Info.u.cqi.cqi < RG_SCH_CMN_MAX_CQI))
16132       {
16133          ueDl->cqiFlag = TRUE;
16134          /* ccpu00117452 - MOD - Changed macro name from
16135             RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16136 #ifdef RGR_CQI_REPT
16137          *isCqiAvail = TRUE;
16138 #endif
16139          ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode11Info.u.cqi.cqi;
16140          if (pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.pres)
16141          {
16142             RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16143                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16144                                      pucchCqi->u.mode11Info.u.cqi.wideDiffCqi.val);
16145 #ifdef RGR_CQI_REPT
16146             /* ccpu00117259 - ADD - Considering second codeword CQI info
16147                incase of MIMO for CQI Reporting */
16148             *is2ndCwCqiAvail = TRUE;
16149 #endif
16150          }
16151       }
16152       else
16153       {
16154          RETVOID;
16155       }
16156       rgSCHCmnDlSetUePmi(cell, ue, \
16157             pucchCqi->u.mode11Info.u.cqi.pmi);
16158    }
16159    else if (pucchCqi->u.mode11Info.type == TFU_RPT_RI)
16160    {
16161       if( RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode11Info.u.ri))
16162       {
16163          rgSCHCmnDlSetUeRi(cell, ue,  pucchCqi->u.mode11Info.u.ri,
16164                            TRUE);
16165       }
16166       else
16167       {
16168          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16169             pucchCqi->u.mode11Info.u.ri,ue->ueId);
16170          RETVOID;
16171       }
16172    }
16173 }
16174
16175 /**
16176  * @brief This function Updates the DL CQI on PUCCH for the UE.
16177  *
16178  * @details
16179  *
16180  *     Function: rgSCHCmnDlProcCqiMode20
16181  *
16182  *     This function updates the DL CQI on PUCCH for the UE.
16183  *
16184  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16185  *
16186  *     Processing Steps:
16187  *       Process CQI MODE 20
16188  *  @param[in] RgSchCellCb     *cell
16189  *  @param[in] RgSchUeCb       *ue
16190  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16191  *  @return  S16
16192  *      -# ROK
16193  *      -# RFAILED
16194  **/
16195 #ifdef RGR_CQI_REPT
16196 #ifdef ANSI
16197 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16198 (
16199  RgSchCellCb        *cell,
16200  RgSchUeCb          *ue,
16201  TfuDlCqiPucch      *pucchCqi,
16202  Bool               *isCqiAvail
16203  )
16204 #else
16205 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
16206  RgSchCellCb        *cell;
16207  RgSchUeCb          *ue;
16208  TfuDlCqiPucch      *pucchCqi;
16209  Bool               *isCqiAvail;
16210 #endif
16211 #else
16212 #ifdef ANSI
16213 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20
16214 (
16215  RgSchCellCb        *cell,
16216  RgSchUeCb          *ue,
16217  TfuDlCqiPucch      *pucchCqi
16218  )
16219 #else
16220 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
16221  RgSchCellCb        *cell;
16222  RgSchUeCb          *ue;
16223  TfuDlCqiPucch      *pucchCqi;
16224 #endif
16225 #endif
16226 {
16227    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16228    TRC2(rgSCHCmnDlProcCqiMode20);
16229
16230    if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
16231    {
16232       if (pucchCqi->u.mode20Info.u.cqi.isWideband)
16233       {
16234          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16235          if((pucchCqi->u.mode20Info.u.cqi.u.wideCqi) &&
16236                (pucchCqi->u.mode20Info.u.cqi.u.wideCqi < RG_SCH_CMN_MAX_CQI))
16237          {
16238             ueDl->cqiFlag = TRUE;
16239             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode20Info.u.cqi.\
16240                                            u.wideCqi;
16241             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16242             /* ccpu00117452 - MOD - Changed macro name from
16243                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16244 #ifdef RGR_CQI_REPT
16245             *isCqiAvail = TRUE;
16246 #endif
16247          }
16248          else
16249          {
16250             RETVOID;
16251          }
16252       }
16253    }
16254    else if (pucchCqi->u.mode20Info.type == TFU_RPT_RI)
16255    {
16256       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode20Info.u.ri))
16257       {
16258          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode20Info.u.ri, 
16259                            TRUE);
16260       }
16261       else
16262       {
16263          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16264             pucchCqi->u.mode20Info.u.ri,ue->ueId);
16265          RETVOID;
16266       }
16267    }
16268 }
16269
16270
16271 /**
16272  * @brief This function Updates the DL CQI on PUCCH for the UE.
16273  *
16274  * @details
16275  *
16276  *     Function: rgSCHCmnDlProcCqiMode21
16277  *
16278  *     This function updates the DL CQI on PUCCH for the UE.
16279  *
16280  *     Invoked by: rgSCHCmnDlCqiOnPucchInd
16281  *
16282  *     Processing Steps:
16283  *       Process CQI MODE 21
16284  *  @param[in] RgSchCellCb     *cell
16285  *  @param[in] RgSchUeCb       *ue
16286  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16287  *  @return  S16
16288  *      -# ROK
16289  *      -# RFAILED
16290  **/
16291 #ifdef RGR_CQI_REPT
16292 #ifdef ANSI
16293 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16294 (
16295  RgSchCellCb        *cell,
16296  RgSchUeCb          *ue,
16297  TfuDlCqiPucch      *pucchCqi,
16298  Bool               *isCqiAvail,
16299  Bool               *is2ndCwCqiAvail
16300  )
16301 #else
16302 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
16303    RgSchCellCb        *cell;
16304    RgSchUeCb          *ue;
16305  TfuDlCqiPucch        *pucchCqi;
16306    TfuDlCqiRpt        *dlCqiRpt;
16307    Bool               *isCqiAvail;
16308    Bool               *is2ndCwCqiAvail;
16309 #endif
16310 #else
16311 #ifdef ANSI
16312 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21
16313 (
16314  RgSchCellCb        *cell,
16315  RgSchUeCb          *ue,
16316  TfuDlCqiPucch      *pucchCqi
16317  )
16318 #else
16319 PRIVATE INLINE Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
16320  RgSchCellCb        *cell;
16321  RgSchUeCb          *ue;
16322  TfuDlCqiPucch      *pucchCqi;
16323 #endif
16324 #endif
16325 {
16326    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16327    TRC2(rgSCHCmnDlProcCqiMode21);
16328
16329    if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
16330    {
16331       ue->mimoInfo.puschFdbkVld  = FALSE;
16332       if (pucchCqi->u.mode21Info.u.cqi.isWideband)
16333       {
16334          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16335          if((pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi) &&
16336                (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.cqi < RG_SCH_CMN_MAX_CQI))
16337          {
16338             ueDl->cqiFlag = TRUE;
16339             ueDl->mimoInfo.cwInfo[0].cqi = pucchCqi->u.mode21Info.u.cqi.\
16340                                            u.wideCqi.cqi;
16341             if (pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.pres)
16342             {
16343                RG_SCH_UPDT_CW2_CQI(ueDl->mimoInfo.cwInfo[0].cqi, \
16344                                      ueDl->mimoInfo.cwInfo[1].cqi, \
16345                                      pucchCqi->u.mode21Info.u.cqi.u.wideCqi.diffCqi.val);
16346 #ifdef RGR_CQI_REPT
16347                /* ccpu00117259 - ADD - Considering second codeword CQI info
16348                   incase of MIMO for CQI Reporting */
16349                *is2ndCwCqiAvail = TRUE;
16350 #endif
16351             }
16352             /* ccpu00117452 - MOD - Changed macro name from
16353                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16354 #ifdef RGR_CQI_REPT
16355             *isCqiAvail = TRUE;
16356 #endif
16357          }
16358          else
16359          {
16360             RETVOID;
16361          }
16362          rgSCHCmnDlSetUePmi(cell, ue, \
16363                pucchCqi->u.mode21Info.u.cqi.u.wideCqi.pmi);
16364       }
16365    }
16366    else if (pucchCqi->u.mode21Info.type == TFU_RPT_RI)
16367    {
16368       if(RG_SCH_CMN_IS_RI_VALID(pucchCqi->u.mode21Info.u.ri))
16369       {
16370          rgSCHCmnDlSetUeRi(cell, ue, pucchCqi->u.mode21Info.u.ri,
16371                            TRUE);
16372       }
16373       else
16374       {
16375          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Invalid RI value(%x) CRNTI:%d",
16376             pucchCqi->u.mode21Info.u.ri,ue->ueId);
16377          RETVOID;
16378       }
16379    }
16380 }
16381
16382
16383 /**
16384  * @brief This function Updates the DL CQI on PUCCH for the UE.
16385  *
16386  * @details
16387  *
16388  *     Function: rgSCHCmnDlCqiOnPucchInd
16389  *
16390  *     This function updates the DL CQI on PUCCH for the UE.
16391  *
16392  *     Invoked by: rgSCHCmnDlCqiInd
16393  *
16394  *     Processing Steps:
16395  *     - Depending on the reporting mode of the PUCCH, the CQI/PMI/RI values
16396  *       are updated and stored for each UE
16397  *
16398  *  @param[in] RgSchCellCb     *cell
16399  *  @param[in] RgSchUeCb       *ue
16400  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16401  *  @return  S16
16402  *      -# ROK
16403  *      -# RFAILED
16404  **/
16405 #ifdef RGR_CQI_REPT
16406 #ifdef ANSI
16407 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16408 (
16409  RgSchCellCb        *cell,
16410  RgSchUeCb          *ue,
16411  TfuDlCqiPucch      *pucchCqi,
16412  RgrUeCqiRept       *ueCqiRept,
16413  Bool               *isCqiAvail,
16414  Bool               *is2ndCwCqiAvail
16415  )
16416 #else
16417 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16418  RgSchCellCb        *cell;
16419  RgSchUeCb          *ue;
16420  TfuDlCqiPucch      *pucchCqi;
16421  RgrUeCqiRept       *ueCqiRept;
16422  Bool               *isCqiAvail;
16423  Bool               *is2ndCwCqiAvail;
16424 #endif
16425 #else
16426 #ifdef ANSI
16427 PRIVATE Void rgSCHCmnDlCqiOnPucchInd
16428 (
16429  RgSchCellCb        *cell,
16430  RgSchUeCb          *ue,
16431  TfuDlCqiPucch      *pucchCqi
16432  )
16433 #else
16434 PRIVATE Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
16435  RgSchCellCb        *cell;
16436  RgSchUeCb          *ue;
16437  TfuDlCqiPucch      *pucchCqi;
16438 #endif
16439 #endif
16440 {
16441    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16442    TRC2(rgSCHCmnDlCqiOnPucchInd);
16443
16444    /* ccpu00117452 - MOD - Changed
16445       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16446 #ifdef RGR_CQI_REPT
16447    /* Save CQI mode information in the report */
16448    ueCqiRept->cqiMode = pucchCqi->mode;
16449 #endif
16450
16451    switch(pucchCqi->mode)
16452    {
16453       case TFU_PUCCH_CQI_MODE10:
16454 #ifdef RGR_CQI_REPT
16455          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail);
16456 #else
16457          rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi);
16458 #endif
16459          ueDl->cqiFlag = TRUE;
16460          break;
16461       case TFU_PUCCH_CQI_MODE11:
16462 #ifdef RGR_CQI_REPT
16463          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail,
16464                 is2ndCwCqiAvail);
16465 #else
16466          rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi);
16467 #endif
16468          ueDl->cqiFlag = TRUE;
16469          break;
16470       case TFU_PUCCH_CQI_MODE20:
16471 #ifdef RGR_CQI_REPT
16472          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail);
16473 #else
16474          rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi);
16475 #endif
16476          ueDl->cqiFlag = TRUE;
16477          break;
16478       case TFU_PUCCH_CQI_MODE21:
16479 #ifdef RGR_CQI_REPT
16480          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail,
16481                 is2ndCwCqiAvail);
16482 #else
16483          rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi);
16484 #endif
16485          ueDl->cqiFlag = TRUE;
16486          break;
16487       default:
16488          {
16489             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unknown CQI Mode %d",
16490                pucchCqi->mode,ue->ueId);
16491             /* ccpu00117452 - MOD - Changed macro name from
16492                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16493 #ifdef RGR_CQI_REPT
16494             *isCqiAvail = FALSE;
16495 #endif
16496          }
16497          break;
16498    }
16499
16500   RETVOID;
16501 }  /* rgSCHCmnDlCqiOnPucchInd */
16502
16503
16504 /**
16505  * @brief This function Updates the DL CQI on PUSCH for the UE.
16506  *
16507  * @details
16508  *
16509  *     Function: rgSCHCmnDlCqiOnPuschInd
16510  *
16511  *     This function updates the DL CQI on PUSCH for the UE.
16512  *
16513  *     Invoked by: rgSCHCmnDlCqiInd
16514  *
16515  *     Processing Steps:
16516  *     - Depending on the reporting mode of the PUSCH, the CQI/PMI/RI values
16517  *       are updated and stored for each UE
16518  *
16519  *  @param[in] RgSchCellCb     *cell
16520  *  @param[in] RgSchUeCb       *ue
16521  *  @param[in] TfuDlCqiRpt     *dlCqiRpt
16522  *  @return  S16
16523  *      -# ROK
16524  *      -# RFAILED
16525  **/
16526 #ifdef RGR_CQI_REPT
16527 #ifdef ANSI
16528 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16529 (
16530  RgSchCellCb        *cell,
16531  RgSchUeCb          *ue,
16532  TfuDlCqiPusch      *puschCqi,
16533  RgrUeCqiRept       *ueCqiRept,
16534  Bool               *isCqiAvail,
16535  Bool               *is2ndCwCqiAvail
16536  )
16537 #else
16538 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
16539  RgSchCellCb        *cell;
16540  RgSchUeCb          *ue;
16541  TfuDlCqiPusch      *puschCqi;
16542  RgrUeCqiRept       *ueCqiRept;
16543  Bool               *isCqiAvail;
16544  Bool               *is2ndCwCqiAvail;
16545 #endif
16546 #else
16547 #ifdef ANSI
16548 PRIVATE Void rgSCHCmnDlCqiOnPuschInd
16549 (
16550  RgSchCellCb        *cell,
16551  RgSchUeCb          *ue,
16552  TfuDlCqiPusch      *puschCqi
16553  )
16554 #else
16555 PRIVATE Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
16556    RgSchCellCb        *cell;
16557    RgSchUeCb          *ue;
16558    TfuDlCqiPusch      *puschCqi;
16559 #endif
16560 #endif
16561 {
16562    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16563    U32 prevRiVal = 0; 
16564    TRC2(rgSCHCmnDlCqiOnPuschInd);
16565    if (puschCqi->ri.pres == PRSNT_NODEF)
16566    {
16567       if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
16568       {
16569          /* Saving the previous ri value to revert back
16570             in  case PMI update failed */
16571          if (RGR_UE_TM_4 == ue->mimoInfo.txMode ) /* Cheking for TM4. TM8 check later */
16572          {
16573             prevRiVal = ueDl->mimoInfo.ri;
16574          }
16575          rgSCHCmnDlSetUeRi(cell, ue, puschCqi->ri.val, FALSE);
16576       }
16577       else
16578       {
16579          RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
16580             puschCqi->ri.val,ue->ueId);
16581          RETVOID;
16582       }
16583    }
16584    ue->mimoInfo.puschFdbkVld  = FALSE;
16585    /* ccpu00117452 - MOD - Changed macro name from
16586       RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16587 #ifdef RGR_CQI_REPT
16588    /* Save CQI mode information in the report */
16589    ueCqiRept->cqiMode = puschCqi->mode;
16590    /* ccpu00117259 - DEL - removed default setting of isCqiAvail to TRUE */
16591 #endif
16592
16593    switch(puschCqi->mode)
16594    {
16595       case TFU_PUSCH_CQI_MODE_20:
16596          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16597          /* Checking whether the decoded CQI is a value between 1 and 15*/
16598          if((puschCqi->u.mode20Info.wideBandCqi) &&
16599                (puschCqi->u.mode20Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16600          {
16601             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode20Info.wideBandCqi;
16602             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16603             /* ccpu00117452 - MOD - Changed macro name from
16604                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16605 #ifdef RGR_CQI_REPT
16606            *isCqiAvail = TRUE;
16607 #endif
16608          }
16609          else
16610          {
16611             RETVOID;
16612          }
16613          break;
16614       case TFU_PUSCH_CQI_MODE_30:
16615          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16616          if((puschCqi->u.mode30Info.wideBandCqi) &&
16617                (puschCqi->u.mode30Info.wideBandCqi < RG_SCH_CMN_MAX_CQI))
16618          {
16619             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode30Info.wideBandCqi;
16620             ueDl->mimoInfo.cwInfo[1].cqi = ueDl->mimoInfo.cwInfo[0].cqi;
16621             /* ccpu00117452 - MOD - Changed macro name from
16622                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16623 #ifdef RGR_CQI_REPT
16624             *isCqiAvail = TRUE;
16625 #endif
16626 #ifdef CA_DBG
16627             {
16628                extern U32 gACqiRcvdCount;
16629                gACqiRcvdCount++;
16630             
16631             }
16632 #endif
16633          }
16634          else
16635          {
16636             RETVOID;
16637          }
16638          break;
16639       case TFU_PUSCH_CQI_MODE_12:
16640          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16641          if((puschCqi->u.mode12Info.cqiIdx[0]) &&
16642                (puschCqi->u.mode12Info.cqiIdx[0] < RG_SCH_CMN_MAX_CQI))
16643          {
16644             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode12Info.cqiIdx[0];
16645             /* ccpu00117452 - MOD - Changed macro name from
16646                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16647 #ifdef RGR_CQI_REPT
16648             *isCqiAvail = TRUE;
16649 #endif
16650          }
16651          else
16652          {
16653             RETVOID;
16654          }
16655          if((puschCqi->u.mode12Info.cqiIdx[1]) &&
16656                (puschCqi->u.mode12Info.cqiIdx[1] < RG_SCH_CMN_MAX_CQI))
16657          {
16658             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode12Info.cqiIdx[1];
16659             /* ccpu00117452 - MOD - Changed macro name from
16660                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16661 #ifdef RGR_CQI_REPT
16662             /* ccpu00117259 - ADD - Considering second codeword CQI info
16663                incase of MIMO for CQI Reporting */
16664             *is2ndCwCqiAvail = TRUE;
16665 #endif
16666          }
16667          else
16668          {
16669             RETVOID;
16670          }
16671          ue->mimoInfo.puschFdbkVld  = TRUE;
16672          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_12;
16673          ue->mimoInfo.puschPmiInfo.u.mode12Info = puschCqi->u.mode12Info;
16674          /*  : resetting this is time based. Make use of CQI reporting
16675           * periodicity, DELTA's in determining the exact time at which this
16676           * need to be reset. */
16677          break;
16678       case TFU_PUSCH_CQI_MODE_22:
16679          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16680          if((puschCqi->u.mode22Info.wideBandCqi[0]) &&
16681                (puschCqi->u.mode22Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16682          {
16683             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode22Info.wideBandCqi[0];
16684             /* ccpu00117452 - MOD - Changed macro name from
16685                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16686 #ifdef RGR_CQI_REPT
16687             *isCqiAvail = TRUE;
16688 #endif
16689          }
16690          else
16691          {
16692             RETVOID;
16693          }
16694          if((puschCqi->u.mode22Info.wideBandCqi[1]) &&
16695                (puschCqi->u.mode22Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16696          {
16697             ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode22Info.wideBandCqi[1];
16698             /* ccpu00117452 - MOD - Changed macro name from
16699                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16700 #ifdef RGR_CQI_REPT
16701             /* ccpu00117259 - ADD - Considering second codeword CQI info
16702                incase of MIMO for CQI Reporting */
16703             *is2ndCwCqiAvail = TRUE;
16704 #endif
16705          }
16706          else
16707          {
16708             RETVOID;
16709          }
16710          rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode22Info.wideBandPmi);
16711          ue->mimoInfo.puschFdbkVld  = TRUE;
16712          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_22;
16713          ue->mimoInfo.puschPmiInfo.u.mode22Info = puschCqi->u.mode22Info;
16714          break;
16715       case TFU_PUSCH_CQI_MODE_31:
16716          /*ccpu00109787 - ADD - Check for non-zero CQI*/
16717          if((puschCqi->u.mode31Info.wideBandCqi[0]) &&
16718                (puschCqi->u.mode31Info.wideBandCqi[0] < RG_SCH_CMN_MAX_CQI))
16719          {
16720             ueDl->mimoInfo.cwInfo[0].cqi = puschCqi->u.mode31Info.wideBandCqi[0];
16721             /* ccpu00117452 - MOD - Changed macro name from
16722                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16723 #ifdef RGR_CQI_REPT
16724             *isCqiAvail = TRUE;
16725 #endif
16726          }
16727          if (ueDl->mimoInfo.ri > 1)
16728          {
16729            if((puschCqi->u.mode31Info.wideBandCqi[1]) &&
16730                (puschCqi->u.mode31Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
16731            {
16732              ueDl->mimoInfo.cwInfo[1].cqi = puschCqi->u.mode31Info.wideBandCqi[1];
16733             /* ccpu00117452 - MOD - Changed macro name from
16734                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16735 #ifdef RGR_CQI_REPT
16736             /* ccpu00117259 - ADD - Considering second codeword CQI info
16737                incase of MIMO for CQI Reporting */
16738              *is2ndCwCqiAvail = TRUE;
16739 #endif
16740            }
16741          }
16742          if (rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode31Info.pmi) != ROK)
16743          {
16744             /* To avoid Rank and PMI inconsistency */
16745             if ((puschCqi->ri.pres == PRSNT_NODEF) &&
16746                 (RGR_UE_TM_4 == ue->mimoInfo.txMode)) /* checking for TM4. TM8 check later */
16747             {
16748                ueDl->mimoInfo.ri = prevRiVal;
16749             }
16750          }
16751          ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_31;
16752          ue->mimoInfo.puschPmiInfo.u.mode31Info = puschCqi->u.mode31Info;
16753          break;
16754       default:
16755          {
16756             RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,  "Unknown CQI Mode %d CRNTI:%d",
16757                puschCqi->mode,ue->ueId);
16758             /*  CQI decoding failed revert the RI to previous value */
16759             if ((puschCqi->ri.pres == PRSNT_NODEF) &&
16760                 (RGR_UE_TM_4 == ue->mimoInfo.txMode)) /* checking for TM4. TM8 check later */
16761             {
16762                ueDl->mimoInfo.ri = prevRiVal;
16763             }
16764             /* ccpu00117452 - MOD - Changed macro name from
16765                RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16766 #ifdef RGR_CQI_REPT
16767            *isCqiAvail = FALSE;
16768             /* ccpu00117259 - ADD - Considering second codeword CQI info
16769                incase of MIMO for CQI Reporting */
16770             *is2ndCwCqiAvail = FALSE;
16771 #endif
16772          }
16773          break;
16774    }
16775
16776    RETVOID;
16777 }  /* rgSCHCmnDlCqiOnPuschInd */
16778
16779 \f
16780 /**
16781  * @brief This function Updates the DL CQI for the UE.
16782  *
16783  * @details
16784  *
16785  *     Function: rgSCHCmnDlCqiInd
16786  *     Purpose:  Updates the DL CQI for the UE
16787  *
16788  *     Invoked by: TOM
16789  *
16790  *  @param[in]  RgSchCellCb        *cell
16791  *  @param[in]  RgSchUeCb          *ue
16792  *  @param[in]  TfuDlCqiRpt        *dlCqi
16793  *  @return  Void
16794  *
16795  **/
16796 #ifdef ANSI
16797 PUBLIC Void rgSCHCmnDlCqiInd
16798 (
16799 RgSchCellCb        *cell,
16800 RgSchUeCb          *ue,
16801 Bool               isPucchInfo,
16802 Void               *dlCqi,
16803 CmLteTimingInfo    timingInfo
16804 )
16805 #else
16806 PUBLIC Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
16807 RgSchCellCb        *cell;
16808 RgSchUeCb          *ue;
16809 Bool               isPucchInfo;
16810 Void               *dlCqi;
16811 CmLteTimingInfo    timingInfo;
16812 #endif
16813 {
16814    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
16815 /* ccpu00117452 - MOD - Changed macro name from
16816    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16817 #ifdef RGR_CQI_REPT
16818    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
16819    RgrUeCqiRept   ueCqiRept = {{0}};
16820    Bool           isCqiAvail = FALSE;
16821    /* ccpu00117259 - ADD - Considering second codeword CQI info
16822       incase of MIMO for CQI Reporting */
16823    Bool           is2ndCwCqiAvail = FALSE;
16824 #endif
16825
16826    TRC2(rgSCHCmnDlCqiInd);
16827
16828 #ifdef RGR_CQI_REPT
16829    if (isPucchInfo)
16830    {
16831       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi, &ueCqiRept, &isCqiAvail, &is2ndCwCqiAvail);
16832    }
16833    else
16834    {
16835       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi, &ueCqiRept,  &isCqiAvail, &is2ndCwCqiAvail);
16836    }
16837 #else
16838    if (isPucchInfo)
16839    {
16840       rgSCHCmnDlCqiOnPucchInd(cell, ue, (TfuDlCqiPucch *)dlCqi);
16841    }
16842    else
16843    {
16844       rgSCHCmnDlCqiOnPuschInd(cell, ue, (TfuDlCqiPusch *)dlCqi);
16845    }
16846 #endif
16847
16848 #ifdef CQI_CONFBITMASK_DROP
16849    if(!ue->cqiConfBitMask)
16850    {
16851       if (ueDl->mimoInfo.cwInfo[0].cqi >15)
16852       {
16853          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16854          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16855       }
16856       else if ( ueDl->mimoInfo.cwInfo[0].cqi >= ue->prevCqi)
16857       {
16858          ue->prevCqi = ueDl->mimoInfo.cwInfo[0].cqi;
16859       }
16860       else
16861       {
16862          U8 dlCqiDeltaPrev = 0;
16863          dlCqiDeltaPrev = ue->prevCqi - ueDl->mimoInfo.cwInfo[0].cqi;
16864          if (dlCqiDeltaPrev > 3)
16865             dlCqiDeltaPrev = 3;
16866          if ((ue->prevCqi - dlCqiDeltaPrev) < 6)
16867          {
16868             ue->prevCqi = 6;
16869          }
16870          else 
16871          {
16872             ue->prevCqi = ue->prevCqi - dlCqiDeltaPrev;
16873          }
16874          ueDl->mimoInfo.cwInfo[0].cqi = ue->prevCqi;
16875          ueDl->mimoInfo.cwInfo[1].cqi = ue->prevCqi;
16876
16877       }
16878    }
16879 #endif
16880
16881 /* ccpu00117452 - MOD - Changed macro name from
16882    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
16883 #ifdef RGR_CQI_REPT
16884    /* ccpu00117259 - ADD - Considering second codeword CQI info
16885       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail\
16886       in 'if' condition*/
16887    if (RG_SCH_CQIR_IS_PUSHNCQI_ENBLE(ue) && (isCqiAvail || is2ndCwCqiAvail))
16888    {
16889       ueCqiRept.cqi[0] = ueDl->mimoInfo.cwInfo[0].cqi;
16890
16891    /* ccpu00117259 - ADD - Considering second codeword CQI info
16892       incase of MIMO for CQI Reporting - added is2ndCwCqiAvail
16893       in 'if' condition*/
16894       ueCqiRept.cqi[1] = 0;
16895       if(is2ndCwCqiAvail)
16896       {
16897          ueCqiRept.cqi[1] = ueDl->mimoInfo.cwInfo[1].cqi;
16898       }
16899       rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, &ueCqiRept);
16900
16901    }
16902 #endif
16903 #ifdef DL_LA
16904    rgSCHCmnDlSetUeAllocLmtLa(cell, ue);
16905    rgSCHCheckAndSetTxScheme(cell, ue);
16906 #else
16907 #ifdef EMTC_ENABLE   
16908    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), ue->isEmtcUe);
16909 #else 
16910    rgSCHCmnDlSetUeAllocLmt(cell, RG_SCH_CMN_GET_DL_UE(ue,cell), FALSE);
16911 #endif   
16912 #endif
16913
16914    if (cellSch->dl.isDlFreqSel)
16915    {
16916       cellSch->apisDlfs->rgSCHDlfsDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo);
16917    }
16918 #ifdef LTEMAC_SPS
16919    /* Call SPS module to update CQI indication */
16920    rgSCHCmnSpsDlCqiIndHndlr(cell, ue, timingInfo);
16921 #endif
16922    /* Call Specific scheduler to process on dlCqiInd */
16923 #ifdef EMTC_ENABLE
16924    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
16925    {
16926       cellSch->apisEmtcDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16927    }
16928    else
16929 #endif
16930    {
16931       cellSch->apisDl->rgSCHDlCqiInd(cell, ue, isPucchInfo, dlCqi);
16932    }
16933
16934 #ifdef RG_PFS_STATS
16935    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].avgCqi += 
16936       ueDl->mimoInfo.cwInfo[0].cqi;
16937    ue->pfsStats.cqiStats[(RG_SCH_GET_SCELL_INDEX(ue, cell))].totalCqiOcc++; 
16938 #endif
16939
16940 #ifdef SCH_STATS
16941    ueDl->avgCqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16942    ueDl->numCqiOccns++;
16943    if (ueDl->mimoInfo.ri == 1)
16944    {
16945       ueDl->numRi1++;
16946    }
16947    else
16948    {
16949       ueDl->numRi2++;
16950    }
16951 #endif
16952
16953 #ifdef TENB_STATS
16954    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16955    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16956    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw0Cqi ++;
16957    ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlNumCw1Cqi ++;
16958    cell->tenbStats->sch.dlSumCw0Cqi +=  ueDl->mimoInfo.cwInfo[0].cqi;
16959    cell->tenbStats->sch.dlSumCw1Cqi +=  ueDl->mimoInfo.cwInfo[1].cqi;
16960    cell->tenbStats->sch.dlNumCw0Cqi ++;
16961    cell->tenbStats->sch.dlNumCw1Cqi ++;
16962 #endif
16963    RETVOID;
16964 }
16965
16966 #ifdef TFU_UPGRADE
16967 /**
16968  * @brief This function calculates the wideband CQI from SNR
16969  *            reported for each RB.
16970  *
16971  * @details
16972  *
16973  *     Function: rgSCHCmnCalcWcqiFrmSnr
16974  *     Purpose:  Wideband CQI calculation from SNR
16975  *
16976  *     Invoked by: RG SCH
16977  *
16978  *  @param[in]  RgSchCellCb        *cell
16979  *  @param[in]  TfuSrsRpt        *srsRpt,
16980  *  @return  Wideband CQI
16981  *
16982  **/
16983 #ifdef ANSI
16984 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr
16985 (
16986  RgSchCellCb        *cell,
16987  TfuSrsRpt        *srsRpt
16988  )
16989 #else
16990 PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
16991    RgSchCellCb        *cell;
16992    TfuSrsRpt            *srsRpt;
16993 #endif
16994 {
16995    U8 wideCqi=1; /*Calculated value from SNR*/
16996    TRC2(rgSCHCmnCalcWcqiFrmSnr);
16997    /*Need to map a certain SNR with a WideCQI value.
16998     * The CQI calculation is still primitive. Further, need to
16999     * use a improvized method for calculating WideCQI from SNR*/
17000        if (srsRpt->snr[0] <=50)
17001        {
17002            wideCqi=3;
17003        }
17004        else if (srsRpt->snr[0]>=51 && srsRpt->snr[0] <=100)
17005        {
17006            wideCqi=6;
17007        }
17008        else if (srsRpt->snr[0]>=101 && srsRpt->snr[0] <=150)
17009        {
17010            wideCqi=9;
17011        }
17012        else if (srsRpt->snr[0]>=151 && srsRpt->snr[0] <=200)
17013        {
17014            wideCqi=12;
17015        }
17016        else if (srsRpt->snr[0]>=201 && srsRpt->snr[0] <=250)
17017        {
17018            wideCqi=14;
17019        }
17020        else
17021        {
17022            wideCqi=15;
17023        }
17024    RETVALUE(wideCqi);
17025 }/*rgSCHCmnCalcWcqiFrmSnr*/
17026
17027
17028 /**
17029  * @brief This function Updates the SRS for the UE.
17030  *
17031  * @details
17032  *
17033  *     Function: rgSCHCmnSrsInd
17034  *     Purpose:  Updates the UL SRS for the UE
17035  *
17036  *     Invoked by: TOM
17037  *
17038  *  @param[in]  RgSchCellCb        *cell
17039  *  @param[in]  RgSchUeCb          *ue
17040  *  @param[in]  TfuSrsRpt        *srsRpt,
17041  *  @return  Void
17042  *
17043  **/
17044 #ifdef ANSI
17045 PUBLIC Void rgSCHCmnSrsInd
17046 (
17047  RgSchCellCb        *cell,
17048  RgSchUeCb          *ue,
17049  TfuSrsRpt        *srsRpt,
17050  CmLteTimingInfo    timingInfo
17051  )
17052 #else
17053 PUBLIC Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
17054     RgSchCellCb        *cell;
17055     RgSchUeCb          *ue;
17056     TfuSrsRpt            *srsRpt;
17057     CmLteTimingInfo    timingInfo;
17058 #endif
17059 {
17060     U8 wideCqi; /*Calculated value from SNR*/
17061     U32 recReqTime; /*Received Time in TTI*/
17062     TRC2(rgSCHCmnSrsInd);
17063
17064     recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
17065     ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
17066     if(srsRpt->wideCqiPres)
17067     {
17068         wideCqi = srsRpt->wideCqi;
17069     }
17070     else
17071     {
17072         wideCqi = rgSCHCmnCalcWcqiFrmSnr(cell, srsRpt);
17073     }
17074     rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi);
17075     RETVOID;
17076 }/*rgSCHCmnSrsInd*/
17077 #endif
17078
17079 \f
17080 /**
17081  * @brief This function is a handler for TA report for an UE.
17082  *
17083  * @details
17084  *
17085  *     Function: rgSCHCmnDlTARpt
17086  *     Purpose:  Determine based on UE_IDLE_TIME threshold,
17087  *     whether UE needs to be Linked to the scheduler's TA list OR
17088  *     if it needs a PDCCH Order.
17089  *
17090  *
17091  *     Invoked by: TOM
17092  *
17093  *  @param[in]  RgSchCellCb        *cell
17094  *  @param[in]  RgSchUeCb          *ue
17095  *  @return  Void
17096  *
17097  **/
17098 #ifdef ANSI
17099 PUBLIC Void rgSCHCmnDlTARpt
17100 (
17101 RgSchCellCb        *cell,
17102 RgSchUeCb          *ue
17103 )
17104 #else
17105 PUBLIC Void rgSCHCmnDlTARpt(cell, ue)
17106 RgSchCellCb        *cell;
17107 RgSchUeCb          *ue;
17108 #endif
17109 {
17110    RgSchCmnCell    *cellSch = RG_SCH_CMN_GET_CELL(cell);
17111    RgSchCmnDlCell  *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
17112    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
17113    CmLListCp       poInactvLst;
17114
17115    TRC2(rgSCHCmnDlTARpt);
17116
17117    /* RACHO: If UE idle time is more than threshold, then
17118     * set its poInactv pdcch order inactivity  */
17119    /* Fix : syed Ignore if TaTmr is not configured */
17120    if ((ue->dl.taCb.cfgTaTmr) && (rgSCHCmnUeIdleExdThrsld(cell, ue) == ROK))
17121    {
17122       U32 prevDlMsk = ue->dl.dlInactvMask;
17123       U32 prevUlMsk = ue->ul.ulInactvMask;
17124       ue->dl.dlInactvMask |= RG_PDCCHODR_INACTIVE;
17125       ue->ul.ulInactvMask |= RG_PDCCHODR_INACTIVE;
17126       /* Indicate Specific scheduler for this UEs inactivity */
17127       cmLListInit(&poInactvLst);
17128       cmLListAdd2Tail(&poInactvLst, &ueDl->rachInfo.inActUeLnk);
17129       ueDl->rachInfo.inActUeLnk.node = (PTR)ue;
17130       /* Send inactivate ind only if not already sent */
17131       if (prevDlMsk == 0)
17132       {
17133          cellSch->apisDl->rgSCHDlInactvtUes(cell, &poInactvLst);
17134       }
17135       if (prevUlMsk == 0)
17136       {
17137          cellSch->apisUl->rgSCHUlInactvtUes(cell, &poInactvLst);
17138       }
17139    }
17140    else
17141    {
17142       /* Fix: ccpu00124009 Fix for loop in the linked list "cellDl->taLst" */
17143       if (!ue->dlTaLnk.node)
17144       {
17145 #ifdef EMTC_ENABLE
17146          if(cell->emtcEnable)
17147          {
17148             if(ue->isEmtcUe)
17149             {
17150                rgSCHEmtcAddToTaLst(cellDl,ue);
17151             }
17152          }
17153          else
17154 #endif
17155          {
17156
17157             cmLListAdd2Tail(&cellDl->taLst, &ue->dlTaLnk);
17158             ue->dlTaLnk.node = (PTR)ue;
17159          }
17160       }
17161       else
17162       {
17163          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
17164                "<TA>TA duplicate entry attempt failed: UEID:%u", 
17165                ue->ueId);
17166       }
17167    }
17168    RETVOID;
17169 }
17170
17171 #ifdef TFU_UPGRADE
17172 /**
17173  * @brief Indication of UL CQI.
17174  *
17175  * @details
17176  *
17177  *     Function : rgSCHCmnFindUlCqiUlTxAnt
17178  *
17179  *     - Finds the Best Tx Antenna amongst the CQIs received
17180  *         from Two Tx Antennas.
17181  *
17182  *  @param[in]  RgSchCellCb         *cell
17183  *  @param[in]  RgSchUeCb           *ue
17184  *  @param[in]   U8                 wideCqi
17185  *  @return  Void
17186  **/
17187 #ifdef ANSI
17188 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt
17189 (
17190 RgSchCellCb     *cell,
17191 RgSchUeCb       *ue,
17192 U8              wideCqi
17193 )
17194 #else
17195 PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
17196 RgSchCellCb     *cell;
17197 RgSchUeCb       *ue;
17198 U8              wideCqi;
17199 #endif
17200 {
17201    ue->validTxAnt = 1;
17202    RETVOID;
17203 }  /* rgSCHCmnFindUlCqiUlTxAnt */
17204 #endif
17205
17206 /**
17207  * @brief Indication of UL CQI.
17208  *
17209  * @details
17210  *
17211  *     Function : rgSCHCmnUlCqiInd
17212  *
17213  *     - Updates uplink CQI information for the UE. Computes and
17214  *       stores the lowest CQI of CQIs reported in all subbands.
17215  *
17216  *  @param[in]  RgSchCellCb         *cell
17217  *  @param[in]  RgSchUeCb           *ue
17218  *  @param[in]  TfuUlCqiRpt         *ulCqiInfo
17219  *  @return  Void
17220  **/
17221 #ifdef ANSI
17222 PUBLIC Void rgSCHCmnUlCqiInd
17223 (
17224 RgSchCellCb          *cell,
17225 RgSchUeCb            *ue,
17226 TfuUlCqiRpt          *ulCqiInfo
17227 )
17228 #else
17229 PUBLIC Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
17230 RgSchCellCb          *cell;
17231 RgSchUeCb            *ue;
17232 TfuUlCqiRpt          *ulCqiInfo;
17233 #endif
17234 {
17235    RgSchCmnUlUe  *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17236    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
17237 #ifdef UL_LA
17238    U8            iTbsNew;
17239    S32           previTbs;
17240 #endif
17241 #if (defined(SCH_STATS) || defined(TENB_STATS))
17242      CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
17243 #endif   
17244                   
17245    TRC2(rgSCHCmnUlCqiInd);
17246    /*  consider inputs from SRS handlers about SRS occassions
17247     * in determining the UL TX Antenna selection */
17248    ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
17249 #ifdef TFU_UPGRADE
17250    ueUl->validUlCqi = ueUl->crntUlCqi[0];
17251    ue->validTxAnt = 0;
17252 #ifdef UL_LA
17253    iTbsNew  =  rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][ueUl->validUlCqi];
17254    previTbs =  (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
17255
17256    if (RG_ITBS_DIFF(iTbsNew, previTbs) > 5)
17257    {
17258       /* Ignore this iTBS report and mark that last iTBS report was */
17259       /* ignored so that subsequently we reset the LA algorithm     */
17260       ueUl->ulLaCb.lastiTbsIgnored = TRUE;
17261    }
17262    else
17263    {
17264       if (ueUl->ulLaCb.lastiTbsIgnored != TRUE)
17265       {
17266          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17267                                        (80 * ueUl->ulLaCb.cqiBasediTbs))/100;
17268       }
17269       else
17270       {
17271          /* Reset the LA as iTbs in use caught up with the value   */
17272          /* reported by UE.                                        */
17273          ueUl->ulLaCb.cqiBasediTbs = ((20 * iTbsNew * 100) +
17274                                         (80 * previTbs * 100))/100;
17275          ueUl->ulLaCb.deltaiTbs = 0;
17276          ueUl->ulLaCb.lastiTbsIgnored = FALSE;
17277       }
17278    }
17279 #endif 
17280 #endif
17281    rgSCHPwrUlCqiInd(cell, ue);
17282 #ifdef LTEMAC_SPS
17283    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17284    {
17285       rgSCHCmnSpsUlCqiInd(cell, ue);
17286    }
17287 #endif
17288    /* Applicable to only some schedulers */
17289 #ifdef EMTC_ENABLE
17290    if((TRUE == cell->emtcEnable) && (TRUE == ue->isEmtcUe))
17291    {
17292       cellSch->apisEmtcUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17293    }
17294    else
17295 #endif
17296    {
17297       cellSch->apisUl->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
17298    }
17299
17300 #ifdef SCH_STATS
17301    ueUl->numCqiOccns++;
17302    ueUl->avgCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17303 #endif
17304
17305 #ifdef TENB_STATS
17306    {
17307       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17308       ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].ulNumCqi ++;
17309       cell->tenbStats->sch.ulSumCqi += rgSCHCmnUlGetCqi(cell, ue, ueCtg);
17310       cell->tenbStats->sch.ulNumCqi ++;
17311    }
17312 #endif
17313
17314    RETVOID;
17315 }  /* rgSCHCmnUlCqiInd */
17316
17317 /**
17318  * @brief Returns HARQ proc for which data expected now.
17319  *
17320  * @details
17321  *
17322  *     Function: rgSCHCmnUlHqProcForUe
17323  *     Purpose:  This function returns the harq process for
17324  *               which data is expected in the current subframe.
17325  *               It does not validate that the HARQ process
17326  *               has an allocation.
17327  *
17328  *     Invoked by: TOM
17329  *
17330  *  @param[in]  RgSchCellCb        *cell
17331  *  @param[in]  CmLteTimingInfo    frm
17332  *  @param[in]  RgSchUeCb          *ue
17333  *  @param[out] RgSchUlHqProcCb    **procRef
17334  *  @return  Void
17335  **/
17336 #ifdef ANSI
17337 PUBLIC Void rgSCHCmnUlHqProcForUe
17338 (
17339 RgSchCellCb         *cell,
17340 CmLteTimingInfo     frm,
17341 RgSchUeCb           *ue,
17342 RgSchUlHqProcCb     **procRef
17343 )
17344 #else
17345 PUBLIC Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
17346 RgSchCellCb         *cell;
17347 CmLteTimingInfo     frm;
17348 RgSchUeCb           *ue;
17349 RgSchUlHqProcCb     **procRef;
17350 #endif
17351 {
17352 #ifndef RG_5GTF
17353    U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
17354 #endif
17355    TRC2(rgSCHCmnUlHqProcForUe);
17356 #ifndef RG_5GTF
17357    *procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
17358 #else
17359    *procRef = rgSCHUhmGetUlProcByTime(cell, ue, frm);
17360 #endif
17361    RETVOID;
17362 }
17363
17364 #ifdef RG_UNUSED
17365 /**
17366  * @brief Update harq process for allocation.
17367  *
17368  * @details
17369  *
17370  *     Function : rgSCHCmnUpdUlHqProc
17371  *
17372  *     This function is invoked when harq process
17373  *     control block is now in a new memory location
17374  *     thus requiring a pointer/reference update.
17375  *
17376  *  @param[in] RgSchCellCb      *cell
17377  *  @param[in] RgSchUlHqProcCb  *curProc
17378  *  @param[in] RgSchUlHqProcCb  *oldProc
17379  *  @return  S16
17380  *      -# ROK
17381  *      -# RFAILED
17382  **/
17383 #ifdef ANSI
17384 PUBLIC S16 rgSCHCmnUpdUlHqProc
17385 (
17386 RgSchCellCb      *cell,
17387 RgSchUlHqProcCb  *curProc,
17388 RgSchUlHqProcCb  *oldProc
17389 )
17390 #else
17391 PUBLIC S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
17392 RgSchCellCb      *cell;
17393 RgSchUlHqProcCb  *curProc;
17394 RgSchUlHqProcCb  *oldProc;
17395 #endif
17396 {
17397    TRC2(rgSCHCmnUpdUlHqProc);
17398
17399    UNUSED(cell);
17400    UNUSED(oldProc);
17401 #if (ERRCLASS & ERRCLS_DEBUG)
17402    if (curProc->alloc == NULLP)
17403    {
17404       RETVALUE(RFAILED);
17405    }
17406 #endif
17407    curProc->alloc->hqProc = curProc;
17408    RETVALUE(ROK);
17409 }  /* rgSCHCmnUpdUlHqProc */
17410 #endif
17411
17412 /*MS_WORKAROUND for CR FIXME */
17413 /**
17414  * @brief Hsndles BSR timer expiry
17415  *
17416  * @details
17417  *
17418  *     Function : rgSCHCmnBsrTmrExpry
17419  *
17420  *     This function is invoked when periodic BSR timer expires for a UE.
17421  *
17422  *  @param[in] RgSchUeCb        *ue
17423  *  @return  S16
17424  *      -# ROK
17425  *      -# RFAILED
17426  **/
17427 #ifdef ANSI
17428 PUBLIC S16 rgSCHCmnBsrTmrExpry
17429 (
17430 RgSchUeCb  *ueCb
17431 )
17432 #else
17433 PUBLIC S16 rgSCHCmnBsrTmrExpry(ueCb)
17434 RgSchUeCb  *ueCb;
17435 #endif
17436 {
17437    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
17438
17439    TRC2(rgSCHCmnBsrTmrExpry)
17440
17441    ueCb->isSrGrant = TRUE;
17442
17443 #ifdef EMTC_ENABLE
17444    emtcStatsUlBsrTmrTxp++;
17445 #endif
17446
17447 #ifdef EMTC_ENABLE
17448    if(ueCb->cell->emtcEnable)
17449    {
17450       if(ueCb->isEmtcUe)
17451       {
17452          cellSch->apisEmtcUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17453          RETVALUE(ROK);
17454       }
17455    }
17456    else
17457 #endif
17458    {
17459       cellSch->apisUl->rgSCHSrRcvd(ueCb->cell, ueCb);
17460    }
17461
17462    RETVALUE (ROK);
17463 }
17464
17465 /**
17466  * @brief Short BSR update.
17467  *
17468  * @details
17469  *
17470  *     Function : rgSCHCmnUpdBsrShort
17471  *
17472  *     This functions does requisite updates to handle short BSR reporting.
17473  *
17474  *  @param[in]  RgSchCellCb  *cell
17475  *  @param[in]  RgSchUeCb    *ue
17476  *  @param[in]  RgSchLcgCb *ulLcg
17477  *  @param[in]  U8           bsr
17478  *  @param[out] RgSchErrInfo *err
17479  *  @return  S16
17480  *      -# ROK
17481  *      -# RFAILED
17482  **/
17483 #ifdef ANSI
17484 PUBLIC S16 rgSCHCmnUpdBsrShort
17485 (
17486 RgSchCellCb  *cell,
17487 RgSchUeCb    *ue,
17488 RgSchLcgCb *ulLcg,
17489 U8           bsr,
17490 RgSchErrInfo *err
17491 )
17492 #else
17493 PUBLIC S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
17494 RgSchCellCb  *cell;
17495 RgSchUeCb    *ue;
17496 RgSchLcgCb *ulLcg;
17497 U8           bsr;
17498 RgSchErrInfo *err;
17499 #endif
17500 {
17501    U8  lcgCnt;
17502 #ifdef LTE_L2_MEAS
17503    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
17504 #endif
17505    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17506    RgSchCmnLcg  *cmnLcg  = NULLP;
17507
17508 #ifdef LTE_L2_MEAS
17509    U8             idx;
17510 #endif
17511    TRC2(rgSCHCmnUpdBsrShort);
17512
17513    if (!RGSCH_LCG_ISCFGD(ulLcg))
17514    {
17515       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17516       RETVALUE(RFAILED);
17517    }
17518    for (lcgCnt=0; lcgCnt<4; lcgCnt++)
17519    {
17520 #ifdef LTE_L2_MEAS
17521       /* Set BS of all other LCGs to Zero.
17522          If Zero BSR is reported in Short BSR include this LCG too */
17523       if ((lcgCnt != ulLcg->lcgId) ||
17524             (!bsr && !ueUl->hqEnt.numBusyHqProcs))
17525       {
17526          /* If old BO is zero do nothing */
17527          if(((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs != 0)
17528          {
17529             for(idx = 0; idx < ue->ul.lcgArr[lcgCnt].numLch; idx++)
17530             {
17531                if((ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount) &&
17532                  (ue->ulActiveLCs & (1 << 
17533                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1))))
17534                {
17535           /* L2_COUNTER */
17536                  ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->ulUeCount--;
17537                  ue->ulActiveLCs &= ~(1 << 
17538                   (ue->ul.lcgArr[lcgCnt].lcArray[idx]->qciCb->qci -1));
17539                }
17540             }
17541          }
17542       }
17543 #endif
17544       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgCnt]))
17545       {
17546          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->bs = 0;
17547          ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCnt].sch))->reportedBs = 0;
17548       }
17549    }
17550
17551 #ifdef LTE_L2_MEAS
17552    if(ulLcg->lcgId && bsr && (((RgSchCmnLcg *)(ulLcg->sch))->bs == 0))
17553    {
17554       for(idx = 0; idx < ulLcg->numLch; idx++)
17555       {
17556           /* L2_COUNTER */
17557           if (!(ue->ulActiveLCs & (1 << (ulLcg->lcArray[idx]->qciCb->qci -1))))
17558           {
17559              ulLcg->lcArray[idx]->qciCb->ulUeCount++;
17560              ue->ulActiveLCs |= (1 << (ulLcg->lcArray[idx]->qciCb->qci -1));
17561           }
17562       }
17563    }
17564 #endif
17565    /* Resetting the nonGbrLcgBs info here */
17566    ue->ul.nonGbrLcgBs = 0;
17567    ue->ul.nonLcg0Bs = 0;
17568
17569    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17570    
17571    if (TRUE == ue->ul.useExtBSRSizes)
17572    {
17573       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17574    }
17575    else
17576    {
17577       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17578    }
17579    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17580    {
17581       /* TBD check for effGbr != 0 */    
17582       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17583    }
17584    else if (0 == ulLcg->lcgId) 
17585    {
17586       /* This is added for handling LCG0 */
17587       cmnLcg->bs = cmnLcg->reportedBs;
17588    }
17589    else 
17590    {
17591       /* Update non GBR LCG's BS*/
17592       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17593       cmnLcg->bs     = ue->ul.nonGbrLcgBs;
17594    }
17595    ue->ul.totalBsr = cmnLcg->bs;
17596
17597 #ifdef RGR_V1
17598    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (bsr == 0))
17599    {
17600       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17601    }
17602 #endif
17603 #ifdef LTEMAC_SPS
17604    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
17605    {
17606       rgSCHCmnSpsBsrRpt(cell, ue, ulLcg);
17607    }
17608 #endif
17609    rgSCHCmnUpdUlCompEffBsr(ue);
17610
17611 #ifdef EMTC_ENABLE
17612    if(cell->emtcEnable)
17613    {
17614       if(ue->isEmtcUe)
17615       {
17616          cellSch->apisEmtcUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17617          RETVALUE(ROK);
17618       }
17619    }
17620    else
17621 #endif
17622    {
17623    cellSch->apisUl->rgSCHUpdBsrShort(cell, ue, ulLcg, bsr);
17624    }
17625
17626 #ifdef LTE_ADV
17627    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17628    {
17629       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17630       {
17631 #ifndef PAL_ENABLE_UL_CA
17632          if((ue->cellInfo[sCellIdx] != NULLP) &&
17633                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17634 #else
17635          if(ue->cellInfo[sCellIdx] != NULLP)
17636 #endif
17637          {
17638             cellSch->apisUl->rgSCHUpdBsrShort(ue->cellInfo[sCellIdx]->cell, 
17639                   ue, ulLcg, bsr);
17640          }
17641       }
17642    }
17643 #endif 
17644
17645    RETVALUE(ROK);
17646 }
17647
17648 /**
17649  * @brief Truncated BSR update.
17650  *
17651  * @details
17652  *
17653  *     Function : rgSCHCmnUpdBsrTrunc
17654  *
17655  *     This functions does required updates to handle truncated BSR report.
17656  *
17657  *
17658  *  @param[in]  RgSchCellCb  *cell
17659  *  @param[in]  RgSchUeCb    *ue
17660  *  @param[in]  RgSchLcgCb *ulLcg
17661  *  @param[in]  U8           bsr
17662  *  @param[out] RgSchErrInfo *err
17663  *  @return  S16
17664  *      -# ROK
17665  *      -# RFAILED
17666  **/
17667 #ifdef ANSI
17668 PUBLIC S16 rgSCHCmnUpdBsrTrunc
17669 (
17670 RgSchCellCb  *cell,
17671 RgSchUeCb    *ue,
17672 RgSchLcgCb *ulLcg,
17673 U8           bsr,
17674 RgSchErrInfo *err
17675 )
17676 #else
17677 PUBLIC S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
17678 RgSchCellCb  *cell;
17679 RgSchUeCb    *ue;
17680 RgSchLcgCb *ulLcg;
17681 U8           bsr;
17682 RgSchErrInfo *err;
17683 #endif
17684 {
17685    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17686    RgSchCmnLcg  *cmnLcg = NULLP;
17687    S32          cnt;
17688 #ifdef LTE_L2_MEAS
17689    U8     idx;
17690 #endif
17691
17692    TRC2(rgSCHCmnUpdBsrTrunc);
17693
17694    if (!RGSCH_LCG_ISCFGD(ulLcg))
17695    {
17696       err->errCause = RGSCHERR_SCH_LCG_NOT_CFGD;
17697       RETVALUE(RFAILED);
17698    }
17699    /* set all higher prio lcgs bs to 0 and update this lcgs bs and
17700       total bsr= sumofall lcgs bs */
17701    if (ulLcg->lcgId)
17702    {
17703       for (cnt = ulLcg->lcgId-1; cnt >= 0; cnt--)
17704       {
17705 #ifdef LTE_L2_MEAS
17706          /* If Existing BO is zero the don't do anything */
17707          if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs != 0)
17708          {
17709             for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17710             {
17711                /* L2_COUNTERS */
17712                if((ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount) &&
17713                      (ue->ulActiveLCs & (1 << 
17714                                          (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17715                {
17716                   ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount--;
17717                   ue->ulActiveLCs &= ~(1 << 
17718                         (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17719                }
17720             }
17721          }
17722 #endif
17723          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs = 0;
17724          ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->reportedBs = 0;
17725       }
17726    }
17727
17728 #ifdef LTE_L2_MEAS
17729    for (cnt = ulLcg->lcgId; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17730    {
17731       if (ulLcg->lcgId == 0)
17732       {
17733          continue;
17734       }
17735       /* If Existing BO is zero the don't do anything */
17736       if(((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs == 0)
17737       {
17738          for(idx = 0; idx < ue->ul.lcgArr[cnt].numLch; idx++)
17739          {
17740             /* L2_COUNTERS */
17741             if (!(ue->ulActiveLCs & (1 << 
17742                (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1))))
17743             {
17744                ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->ulUeCount++;
17745                ue->ulActiveLCs |= (1 << 
17746                      (ue->ul.lcgArr[cnt].lcArray[idx]->qciCb->qci -1));
17747             }
17748          }
17749       }
17750    }
17751 #endif
17752    ue->ul.nonGbrLcgBs = 0;
17753    ue->ul.nonLcg0Bs = 0;
17754    cmnLcg = ((RgSchCmnLcg *)(ulLcg->sch));
17755    if (TRUE == ue->ul.useExtBSRSizes)
17756    {
17757       cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsr];
17758    }
17759    else
17760    {
17761       cmnLcg->reportedBs = rgSchCmnBsrTbl[bsr];
17762    }
17763    if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17764    {
17765       cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17766    }
17767    else if(ulLcg->lcgId == 0)
17768    {
17769       /* This is for handeling LCG0 */
17770       cmnLcg->bs = cmnLcg->reportedBs;
17771    }
17772    else
17773    {
17774       ue->ul.nonGbrLcgBs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
17775       cmnLcg->bs = ue->ul.nonGbrLcgBs;
17776    }
17777    ue->ul.totalBsr = cmnLcg->bs;
17778
17779    for (cnt = ulLcg->lcgId+1; cnt < RGSCH_MAX_LCG_PER_UE; cnt++)
17780    {
17781       /* TODO: The bs for the other LCGs may be stale because some or all of
17782        * the part of bs may have been already scheduled/data received. Please 
17783        * consider this when truncated BSR is tested/implemented */
17784       ue->ul.totalBsr += ((RgSchCmnLcg *)(ue->ul.lcgArr[cnt].sch))->bs;
17785    }
17786
17787    rgSCHCmnUpdUlCompEffBsr(ue);
17788
17789 #ifdef EMTC_ENABLE
17790    if(cell->emtcEnable)
17791    {
17792       if(ue->isEmtcUe)
17793       {
17794          cellSch->apisEmtcUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17795          RETVALUE(ROK);
17796       }
17797    }
17798    else
17799 #endif
17800    {
17801       cellSch->apisUl->rgSCHUpdBsrTrunc(cell, ue, ulLcg, bsr);
17802    }
17803
17804 #ifdef LTE_ADV
17805    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17806    {
17807       for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
17808       {
17809 #ifndef PAL_ENABLE_UL_CA
17810          if((ue->cellInfo[sCellIdx] != NULLP) &&
17811                (ue->cellInfo[sCellIdx]->sCellState == RG_SCH_SCELL_ACTIVE))
17812 #else
17813          if(ue->cellInfo[sCellIdx] != NULLP)
17814 #endif
17815          {
17816             cellSch->apisUl->rgSCHUpdBsrTrunc(ue->cellInfo[sCellIdx]->cell, ue, ulLcg, bsr);
17817          }
17818       }
17819    }
17820 #endif 
17821
17822    RETVALUE(ROK);
17823 }
17824
17825 /**
17826  * @brief Long BSR update.
17827  *
17828  * @details
17829  *
17830  *     Function : rgSCHCmnUpdBsrLong
17831  *
17832  *     - Update BSRs for all configured LCGs.
17833  *     - Update priority of LCGs if needed.
17834  *     - Update UE's position within/across uplink scheduling queues.
17835  *
17836  *
17837  *  @param[in]  RgSchCellCb  *cell
17838  *  @param[in]  RgSchUeCb    *ue
17839  *  @param[in]  U8 bsArr[]
17840  *  @param[out] RgSchErrInfo *err
17841  *  @return  S16
17842  *      -# ROK
17843  *      -# RFAILED
17844  **/
17845 #ifdef ANSI
17846 PUBLIC S16 rgSCHCmnUpdBsrLong
17847 (
17848 RgSchCellCb  *cell,
17849 RgSchUeCb    *ue,
17850 U8           *bsArr,
17851 RgSchErrInfo *err
17852 )
17853 #else
17854 PUBLIC S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
17855 RgSchCellCb  *cell;
17856 RgSchUeCb    *ue;
17857 U8           *bsArr;
17858 RgSchErrInfo *err;
17859 #endif
17860 {
17861    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
17862    U32           tmpBsArr[4] = {0, 0, 0, 0};
17863    U32           nonGbrBs = 0;
17864 #ifdef LTE_L2_MEAS
17865    U8            idx1;
17866    U8            idx2;
17867 #endif
17868    U32           lcgId;
17869
17870    TRC2(rgSCHCmnUpdBsrLong);
17871
17872 #ifdef LTE_L2_MEAS
17873    for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
17874    {
17875      /* If Old BO is non zero then do nothing */
17876      if ((((RgSchCmnLcg *)(ue->ul.lcgArr[idx1].sch))->bs == 0)
17877         && bsArr[idx1] )
17878      {
17879        for(idx2 = 0; idx2 < ue->ul.lcgArr[idx1].numLch; idx2++)
17880        {
17881           /* L2_COUNTERS */
17882           if (!(ue->ulActiveLCs & (1 << 
17883              (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1))))
17884           {
17885              ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->ulUeCount++;
17886              ue->ulActiveLCs |= (1 << 
17887                (ue->ul.lcgArr[idx1].lcArray[idx2]->qciCb->qci -1));
17888           }
17889        }
17890      }
17891    }
17892 #endif
17893    ue->ul.nonGbrLcgBs = 0;
17894    ue->ul.nonLcg0Bs = 0;
17895
17896    if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[0]))
17897    {
17898       if (TRUE == ue->ul.useExtBSRSizes)
17899       {
17900          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnExtBsrTbl[bsArr[0]];
17901          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnExtBsrTbl[bsArr[0]];
17902          tmpBsArr[0] = rgSchCmnExtBsrTbl[bsArr[0]];
17903       }
17904       else
17905       {
17906          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = rgSchCmnBsrTbl[bsArr[0]];
17907          ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->reportedBs = rgSchCmnBsrTbl[bsArr[0]];
17908          tmpBsArr[0] = rgSchCmnBsrTbl[bsArr[0]];
17909       }
17910    }
17911    for (lcgId = 1; lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
17912    {
17913       if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
17914       {
17915          RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
17916
17917          if (TRUE == ue->ul.useExtBSRSizes)
17918          {
17919             cmnLcg->reportedBs = rgSchCmnExtBsrTbl[bsArr[lcgId]];
17920          }
17921          else
17922          {
17923             cmnLcg->reportedBs = rgSchCmnBsrTbl[bsArr[lcgId]];
17924          }
17925          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
17926          {
17927             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr + cmnLcg->effDeltaMbr);
17928             tmpBsArr[lcgId] = cmnLcg->bs;
17929          }
17930          else
17931          {
17932             nonGbrBs += cmnLcg->reportedBs;
17933             tmpBsArr[lcgId] = cmnLcg->reportedBs;
17934             cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs,ue->ul.effAmbr);
17935          }
17936       }
17937    }
17938    ue->ul.nonGbrLcgBs = RGSCH_MIN(nonGbrBs,ue->ul.effAmbr);
17939
17940    ue->ul.totalBsr = tmpBsArr[0] + tmpBsArr[1] + tmpBsArr[2] + tmpBsArr[3];
17941 #ifdef RGR_V1
17942    if ((ue->bsrTmr.tmrEvnt != TMR_NONE) && (ue->ul.totalBsr == 0))
17943    {
17944       rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
17945    }
17946 #endif
17947
17948 #ifdef LTEMAC_SPS
17949    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE) /* SPS_FIX */
17950    {
17951      if(ue->ul.totalBsr - tmpBsArr[1] == 0)
17952      {/* Updaing the BSR to SPS only if LCG1 BS is present in sps active state */
17953         rgSCHCmnSpsBsrRpt(cell, ue, &ue->ul.lcgArr[1]);
17954      }
17955    }
17956 #endif
17957    rgSCHCmnUpdUlCompEffBsr(ue);
17958
17959 #ifdef EMTC_ENABLE
17960    if(cell->emtcEnable)
17961    {
17962       if(ue->isEmtcUe)
17963       {
17964          cellSch->apisEmtcUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17965          RETVALUE(ROK);
17966       }
17967    }
17968    else
17969 #endif
17970    {
17971    cellSch->apisUl->rgSCHUpdBsrLong(cell, ue, bsArr);
17972    }
17973
17974 #ifdef LTE_ADV
17975    if (ue->ul.isUlCaEnabled  && ue->numSCells)
17976    {
17977       for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
17978       {
17979 #ifndef PAL_ENABLE_UL_CA
17980          if((ue->cellInfo[idx] != NULLP) &&
17981                (ue->cellInfo[idx]->sCellState == RG_SCH_SCELL_ACTIVE))
17982 #else
17983          if(ue->cellInfo[idx] != NULLP)
17984 #endif
17985          {
17986             cellSch->apisUl->rgSCHUpdBsrLong(ue->cellInfo[idx]->cell, ue, bsArr);
17987          }
17988       }
17989    }
17990 #endif 
17991
17992    RETVALUE(ROK);
17993 }
17994
17995 /**
17996  * @brief PHR update.
17997  *
17998  * @details
17999  *
18000  *     Function : rgSCHCmnUpdExtPhr
18001  *
18002  *     Updates extended power headroom information for an UE.
18003  *
18004  *  @param[in]  RgSchCellCb  *cell
18005  *  @param[in]  RgSchUeCb    *ue
18006  *  @param[in]  U8           phr
18007  *  @param[out] RgSchErrInfo *err
18008  *  @return  S16
18009  *      -# ROK
18010  *      -# RFAILED
18011  **/
18012 #ifdef ANSI
18013 PUBLIC S16 rgSCHCmnUpdExtPhr
18014 (
18015 RgSchCellCb    *cell,
18016 RgSchUeCb      *ue,
18017 RgInfExtPhrCEInfo *extPhr,
18018 RgSchErrInfo   *err
18019 )
18020 #else
18021 PUBLIC S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
18022 RgSchCellCb    *cell;
18023 RgSchUeCb      *ue;
18024 RgInfExtPhrCEInfo *extPhr;
18025 RgSchErrInfo   *err;
18026 #endif
18027 {
18028    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18029    RgSchCmnAllocRecord *allRcd;
18030    CmLList             *node = ueUl->ulAllocLst.last;
18031
18032 #ifdef LTEMAC_SPS
18033    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18034 #endif
18035    TRC2(rgSCHCmnUpdExtPhr);
18036
18037    UNUSED(err);
18038
18039    while (node)
18040    {
18041       allRcd = (RgSchCmnAllocRecord *)node->node;
18042       node = node->prev;
18043       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18044       {
18045          rgSCHPwrUpdExtPhr(cell, ue, extPhr, allRcd);
18046          break;
18047       }
18048    }
18049 #ifdef LTEMAC_SPS
18050    if(ulSpsUe->isUlSpsActv)
18051    {
18052       rgSCHCmnSpsPhrInd(cell,ue);
18053    }
18054 #endif
18055
18056    RETVALUE(ROK);
18057 }  /* rgSCHCmnUpdExtPhr */
18058
18059
18060
18061
18062 /**
18063  * @brief PHR update.
18064  *
18065  * @details
18066  *
18067  *     Function : rgSCHCmnUpdPhr
18068  *
18069  *     Updates power headroom information for an UE.
18070  *
18071  *  @param[in]  RgSchCellCb  *cell
18072  *  @param[in]  RgSchUeCb    *ue
18073  *  @param[in]  U8           phr
18074  *  @param[out] RgSchErrInfo *err
18075  *  @return  S16
18076  *      -# ROK
18077  *      -# RFAILED
18078  **/
18079 #ifdef ANSI
18080 PUBLIC S16 rgSCHCmnUpdPhr
18081 (
18082 RgSchCellCb    *cell,
18083 RgSchUeCb      *ue,
18084 U8             phr,
18085 RgSchErrInfo   *err
18086 )
18087 #else
18088 PUBLIC S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
18089 RgSchCellCb    *cell;
18090 RgSchUeCb      *ue;
18091 U8             phr;
18092 RgSchErrInfo   *err;
18093 #endif
18094 {
18095    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18096    RgSchCmnAllocRecord *allRcd;
18097    CmLList             *node = ueUl->ulAllocLst.last;
18098
18099 #ifdef LTEMAC_SPS
18100    RgSchCmnUlUeSpsInfo   *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
18101 #endif
18102    TRC2(rgSCHCmnUpdPhr);
18103
18104    UNUSED(err);
18105
18106    while (node)
18107    {
18108       allRcd = (RgSchCmnAllocRecord *)node->node;
18109       node = node->prev;
18110       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18111       {
18112          rgSCHPwrUpdPhr(cell, ue, phr, allRcd, RG_SCH_CMN_PWR_USE_CFG_MAX_PWR);
18113          break;
18114       }
18115    }
18116 #ifdef LTEMAC_SPS
18117    if(ulSpsUe->isUlSpsActv)
18118    {
18119       rgSCHCmnSpsPhrInd(cell,ue);
18120    }
18121 #endif
18122
18123    RETVALUE(ROK);
18124 }  /* rgSCHCmnUpdPhr */
18125
18126 /**
18127  * @brief UL grant for contention resolution.
18128  *
18129  * @details
18130  *
18131  *     Function : rgSCHCmnContResUlGrant
18132  *
18133  *     Add UE to another queue specifically for CRNTI based contention
18134  *     resolution.
18135  *
18136  *
18137  *  @param[in]  RgSchUeCb    *ue
18138  *  @param[out] RgSchErrInfo *err
18139  *  @return  S16
18140  *      -# ROK
18141  *      -# RFAILED
18142  **/
18143 #ifdef ANSI
18144 PUBLIC S16 rgSCHCmnContResUlGrant
18145 (
18146 RgSchCellCb  *cell,
18147 RgSchUeCb    *ue,
18148 RgSchErrInfo *err
18149 )
18150 #else
18151 PUBLIC S16 rgSCHCmnContResUlGrant(cell, ue, err)
18152 RgSchCellCb  *cell;
18153 RgSchUeCb    *ue;
18154 RgSchErrInfo *err;
18155 #endif
18156 {
18157    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18158    TRC2(rgSCHCmnContResUlGrant);
18159
18160    #ifdef EMTC_ENABLE
18161    if(cell->emtcEnable)
18162    {
18163       if(ue->isEmtcUe)
18164       {
18165          cellSch->apisEmtcUl->rgSCHContResUlGrant(cell, ue);
18166          RETVALUE(ROK);
18167       }
18168    }
18169    else
18170 #endif
18171    {
18172       cellSch->apisUl->rgSCHContResUlGrant(cell, ue);
18173    }
18174    RETVALUE(ROK);
18175 }
18176
18177 /**
18178  * @brief SR reception handling.
18179  *
18180  * @details
18181  *
18182  *     Function : rgSCHCmnSrRcvd
18183  *
18184  *     - Update UE's position within/across uplink scheduling queues
18185  *     - Update priority of LCGs if needed.
18186  *
18187  *  @param[in]  RgSchCellCb  *cell
18188  *  @param[in]  RgSchUeCb    *ue
18189  *  @param[in]  CmLteTimingInfo frm
18190  *  @param[out] RgSchErrInfo *err
18191  *  @return  S16
18192  *      -# ROK
18193  *      -# RFAILED
18194  **/
18195 #ifdef ANSI
18196 PUBLIC S16 rgSCHCmnSrRcvd
18197 (
18198 RgSchCellCb  *cell,
18199 RgSchUeCb    *ue,
18200 CmLteTimingInfo frm,
18201 RgSchErrInfo *err
18202 )
18203 #else
18204 PUBLIC S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
18205 RgSchCellCb  *cell;
18206 RgSchUeCb    *ue;
18207 CmLteTimingInfo frm;
18208 RgSchErrInfo *err;
18209 #endif
18210 {
18211    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
18212    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
18213    CmLList      *node    = ueUl->ulAllocLst.last;
18214
18215    TRC2(rgSCHCmnSrRcvd);
18216
18217 #ifdef EMTC_ENABLE
18218    emtcStatsUlTomSrInd++;
18219 #endif
18220
18221    RGSCH_INCR_SUB_FRAME(frm, 1); /* 1 TTI after the time SR was sent */
18222    while (node)
18223    {
18224       RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)node->node;
18225       if (RGSCH_TIMEINFO_SAME(frm, allRcd->allocTime))
18226       {
18227          break;
18228       }
18229       node = node->prev;
18230    }
18231    //TODO_SID Need to check when it is getting triggered
18232    ue->isSrGrant = TRUE;
18233 #ifdef EMTC_ENABLE
18234    if(cell->emtcEnable)
18235    {
18236       if(ue->isEmtcUe)
18237       {
18238          cellSch->apisEmtcUl->rgSCHSrRcvd(cell, ue);
18239          RETVALUE(ROK);
18240       }
18241    }
18242    else
18243 #endif
18244    {
18245       cellSch->apisUl->rgSCHSrRcvd(cell, ue);
18246    }
18247    RETVALUE(ROK);
18248 }
18249
18250 /**
18251  * @brief Returns first uplink allocation to send reception
18252  *        request to PHY.
18253  *
18254  * @details
18255  *
18256  *     Function: rgSCHCmnFirstRcptnReq(cell)
18257  *     Purpose:  This function returns the first uplink allocation
18258  *               (or NULLP if there is none) in the subframe
18259  *               in which is expected to prepare and send reception
18260  *               request to PHY.
18261  *
18262  *     Invoked by: TOM
18263  *
18264  *  @param[in]  RgSchCellCb      *cell
18265  *  @return  RgSchUlAlloc*
18266  **/
18267 #ifdef ANSI
18268 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq
18269 (
18270 RgSchCellCb      *cell
18271 )
18272 #else
18273 PUBLIC RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
18274 RgSchCellCb      *cell;
18275 #endif
18276 {
18277    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18278 /* ACC_TDD */
18279    RgSchUlAlloc* alloc = NULLP;
18280
18281    TRC2(rgSCHCmnFirstRcptnReq);
18282
18283    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18284    {
18285            RgSchUlSf* sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18286            alloc = rgSCHUtlUlAllocFirst(sf);
18287
18288            if (alloc && alloc->hqProc == NULLP)
18289            {
18290                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18291            }
18292    }
18293
18294    RETVALUE(alloc);
18295 }
18296
18297 /**
18298  * @brief Returns first uplink allocation to send reception
18299  *        request to PHY.
18300  *
18301  * @details
18302  *
18303  *     Function: rgSCHCmnNextRcptnReq(cell)
18304  *     Purpose:  This function returns the next uplink allocation
18305  *               (or NULLP if there is none) in the subframe
18306  *               in which is expected to prepare and send reception
18307  *               request to PHY.
18308  *
18309  *     Invoked by: TOM
18310  *
18311  *  @param[in]  RgSchCellCb      *cell
18312  *  @return  RgSchUlAlloc*
18313  **/
18314 #ifdef ANSI
18315 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq
18316 (
18317 RgSchCellCb      *cell,
18318 RgSchUlAlloc     *alloc
18319 )
18320 #else
18321 PUBLIC RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
18322 RgSchCellCb      *cell;
18323 RgSchUlAlloc     *alloc;
18324 #endif
18325 {
18326    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18327 /* ACC-TDD */
18328    //RgSchUlSf      *sf   = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18329
18330    TRC2(rgSCHCmnNextRcptnReq);
18331 /* ACC-TDD */
18332    if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
18333    {
18334            RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
18335
18336            alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18337            if (alloc && alloc->hqProc == NULLP)
18338            {
18339                    alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18340            }
18341    }
18342    else
18343    {
18344            alloc = NULLP;
18345    }
18346
18347    RETVALUE(alloc);
18348 }
18349 /**
18350  * @brief Collates DRX enabled UE's scheduled in this SF
18351  *
18352  * @details
18353  *
18354  *     Function: rgSCHCmnDrxStrtInActvTmrInUl(cell)
18355  *     Purpose:  This function collates the link
18356  *               of UE's scheduled in this SF who
18357  *               have drx enabled. It then calls
18358  *               DRX specific function to start/restart
18359  *               inactivity timer in Ul
18360  *
18361  *     Invoked by: TOM
18362  *
18363  *  @param[in]  RgSchCellCb      *cell
18364  *  @return Void
18365  **/
18366 #ifdef ANSI
18367 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl
18368 (
18369 RgSchCellCb      *cell
18370 )
18371 #else
18372 PUBLIC Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
18373 RgSchCellCb      *cell;
18374 #endif
18375 {
18376    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18377    RgSchUlSf      *sf     = &(cellUl->ulSfArr[cellUl->schdIdx]);
18378    RgSchUlAlloc   *alloc  = rgSCHUtlUlAllocFirst(sf);
18379    CmLListCp       ulUeLst;
18380    RgSchUeCb       *ueCb;
18381
18382
18383    TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
18384
18385    cmLListInit(&ulUeLst);
18386
18387    while(alloc)
18388    {
18389       ueCb = alloc->ue;
18390
18391       if (ueCb)
18392       {
18393          if (!(alloc->grnt.isRtx) && ueCb->isDrxEnabled && !(ueCb->isSrGrant)
18394 #ifdef LTEMAC_SPS
18395              /* ccpu00139513- DRX inactivity timer should not be started for 
18396               * UL SPS occasions */
18397              && (alloc->hqProc->isSpsOccnHqP == FALSE) 
18398 #endif
18399              )
18400          {
18401             cmLListAdd2Tail(&ulUeLst,&(ueCb->ulDrxInactvTmrLnk));
18402             ueCb->ulDrxInactvTmrLnk.node = (PTR)ueCb;
18403          }
18404       }
18405
18406       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18407    }/*while(alloc)*/
18408
18409    (Void)rgSCHDrxStrtInActvTmr(cell,&ulUeLst,RG_SCH_DRX_UL);
18410
18411    RETVOID;
18412 }
18413
18414
18415 /**
18416  * @brief Returns first uplink allocation to send HARQ feedback
18417  *        request to PHY.
18418  *
18419  * @details
18420  *
18421  *     Function: rgSCHCmnFirstHqFdbkAlloc
18422  *     Purpose:  This function returns the first uplink allocation
18423  *               (or NULLP if there is none) in the subframe
18424  *               for which it is expected to prepare and send HARQ
18425  *               feedback to PHY.
18426  *
18427  *     Invoked by: TOM
18428  *
18429  *  @param[in]  RgSchCellCb      *cell
18430  *  @param[in]  U8               idx
18431  *  @return  RgSchUlAlloc*
18432  **/
18433 #ifdef ANSI
18434 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
18435 (
18436 RgSchCellCb      *cell,
18437 U8               idx 
18438 )
18439 #else
18440 PUBLIC RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
18441 RgSchCellCb      *cell;
18442 U8               idx;
18443 #endif
18444 {
18445    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18446 /* ACC-TDD */
18447    RgSchUlAlloc  *alloc = NULLP;
18448
18449    TRC2(rgSCHCmnFirstHqFdbkAlloc);
18450
18451    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18452    {
18453           RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18454           alloc    = rgSCHUtlUlAllocFirst(sf);
18455
18456           while (alloc && (alloc->hqProc == NULLP))
18457           {
18458                   alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18459           }
18460    }
18461
18462    RETVALUE(alloc);
18463 }
18464
18465 /**
18466  * @brief Returns next allocation to send HARQ feedback for.
18467  *
18468  * @details
18469  *
18470  *     Function: rgSCHCmnNextHqFdbkAlloc(cell)
18471  *     Purpose:  This function returns the next uplink allocation
18472  *               (or NULLP if there is none) in the subframe
18473  *               for which HARQ feedback needs to be sent.
18474  *
18475  *     Invoked by: TOM
18476  *
18477  *  @param[in]  RgSchCellCb      *cell
18478  *  @return  RgSchUlAlloc*
18479  **/
18480 #ifdef ANSI
18481 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
18482 (
18483 RgSchCellCb      *cell,
18484 RgSchUlAlloc     *alloc,
18485 U8               idx 
18486 )
18487 #else
18488 PUBLIC RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
18489 RgSchCellCb      *cell;
18490 RgSchUlAlloc     *alloc;
18491 U8               idx; 
18492 #endif
18493 {
18494    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18495    TRC2(rgSCHCmnNextHqFdbkAlloc);
18496
18497    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
18498    {
18499       RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
18500
18501       alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18502       while (alloc && (alloc->hqProc == NULLP))
18503       {
18504          alloc = rgSCHUtlUlAllocNxt(sf, alloc);
18505       }
18506    }
18507    else
18508    {
18509           alloc = NULLP;
18510    }
18511    RETVALUE(alloc);
18512 }
18513
18514 /***********************************************************
18515  *
18516  *     Func : rgSCHCmnUlGetITbsFrmIMcs
18517  *
18518  *     Desc : Returns the Itbs that is mapped to an Imcs
18519  *            for the case of uplink.
18520  *
18521  *     Ret  :
18522  *
18523  *     Notes:
18524  *
18525  *     File :
18526  *
18527  **********************************************************/
18528 #ifdef ANSI
18529 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs
18530 (
18531 U8          iMcs
18532 )
18533 #else
18534 PUBLIC U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
18535 U8          iMcs;
18536 #endif
18537 {
18538    TRC2(rgSCHCmnUlGetITbsFrmIMcs);
18539
18540    RETVALUE(rgUlIMcsTbl[iMcs].iTbs);
18541 }
18542
18543 /***********************************************************
18544  *
18545  *     Func : rgSCHCmnUlGetIMcsFrmITbs
18546  *
18547  *     Desc : Returns the Imcs that is mapped to an Itbs
18548  *            for the case of uplink.
18549  *
18550  *     Ret  :
18551  *
18552  *     Notes: For iTbs 19, iMcs is dependant on modulation order.
18553  *            Refer to 36.213, Table 8.6.1-1 and 36.306 Table 4.1-2
18554  *            for UE capability information
18555  *
18556  *     File :
18557  *
18558  **********************************************************/
18559 #ifdef ANSI
18560 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs
18561 (
18562 U8                iTbs,
18563 CmLteUeCategory   ueCtg
18564 )
18565 #else
18566 PUBLIC U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
18567 U8                iTbs;
18568 CmLteUeCategory   ueCtg;
18569 #endif
18570 {
18571    U8 iMcs;
18572    TRC2(rgSCHCmnUlGetIMcsFrmITbs);
18573
18574    if (iTbs <= 10)
18575    {
18576       iMcs = iTbs;
18577    }
18578    /*a higher layer can force a 64QAM UE to transmit at 16QAM.
18579     * We currently do not support this. Once the support for such
18580     * is added, ueCtg should be replaced by current transmit
18581     * modulation configuration.Refer to 36.213 -8.6.1
18582     */
18583    else if ( iTbs < 19 )
18584    {
18585       iMcs = iTbs + 1;
18586    }
18587    else if ((iTbs == 19) && (ueCtg != CM_LTE_UE_CAT_5))
18588    {
18589       iMcs = iTbs + 1;
18590    }
18591    else
18592    {
18593       iMcs = iTbs + 2;
18594    }
18595
18596 #ifdef LTE_TDD
18597    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
18598       was seen when IMCS exceeds 20  on T2k TDD*/
18599    if (iMcs > 20)
18600    {
18601       iMcs = 20;
18602    }
18603 #endif
18604
18605    RETVALUE(iMcs);
18606 }
18607
18608 /***********************************************************
18609  *
18610  *     Func : rgSCHCmnUlMinTbBitsForITbs
18611  *
18612  *     Desc : Returns the minimum number of bits that can
18613  *            be given as grant for a specific CQI.
18614  *
18615  *     Ret  :
18616  *
18617  *     Notes:
18618  *
18619  *     File :
18620  *
18621  **********************************************************/
18622 #ifdef ANSI
18623 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs
18624 (
18625 RgSchCmnUlCell     *cellUl,
18626 U8                 iTbs
18627 )
18628 #else
18629 PUBLIC U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
18630 RgSchCmnUlCell   *cellUl;
18631 U8               iTbs;
18632 #endif
18633 {
18634    TRC2(rgSCHCmnUlMinTbBitsForITbs);
18635
18636    RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs); 
18637
18638    RETVALUE(rgTbSzTbl[0][iTbs][cellUl->sbSize-1]);
18639 }
18640
18641 /***********************************************************
18642  *
18643  *     Func : rgSCHCmnUlSbAlloc
18644  *
18645  *     Desc : Given a required 'number of subbands' and a hole,
18646  *            returns a suitable alloc such that the subband
18647  *            allocation size is valid
18648  *
18649  *     Ret  :
18650  *
18651  *     Notes: Does not assume either passed numSb or hole size
18652  *            to be valid for allocation, and hence arrives at
18653  *            an acceptable value.
18654  *     File :
18655  *
18656  **********************************************************/
18657 #ifdef ANSI
18658 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc
18659 (
18660 RgSchUlSf       *sf,
18661 U8              numSb,
18662 RgSchUlHole     *hole
18663 )
18664 #else
18665 PUBLIC RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
18666 RgSchUlSf       *sf;
18667 U8              numSb;
18668 RgSchUlHole     *hole;
18669 #endif
18670 {
18671    U8           holeSz; /* valid hole size */
18672    RgSchUlAlloc *alloc;
18673    TRC2(rgSCHCmnUlSbAlloc);
18674
18675    if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
18676    {
18677       numSb = rgSchCmnMult235Tbl[numSb].match;
18678       if (numSb >= holeSz)
18679       {
18680          alloc = rgSCHUtlUlAllocGetCompHole(sf, hole);
18681       }
18682       else
18683       {
18684          alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18685       }
18686    }
18687    else
18688    {
18689       if (numSb < holeSz)
18690       {
18691          numSb = rgSchCmnMult235Tbl[numSb].match;
18692       }
18693       else
18694       {
18695          numSb = rgSchCmnMult235Tbl[numSb].prvMatch;
18696       }
18697
18698       if ( numSb >= holeSz )
18699       {
18700          numSb = holeSz;
18701       }
18702       alloc = rgSCHUtlUlAllocGetPartHole(sf, numSb, hole);
18703    }
18704    RETVALUE(alloc);
18705 }
18706
18707 /**
18708  * @brief To fill the RgSchCmnUeUlAlloc structure of UeCb.
18709  *
18710  * @details
18711  *
18712  *     Function: rgSCHCmnUlUeFillAllocInfo
18713  *     Purpose:  Specific scheduler to call this API to fill the alloc
18714  *               information.
18715  *
18716  *     Invoked by: Scheduler
18717  *
18718  *  @param[in]  RgSchCellCb      *cell
18719  *  @param[out] RgSchUeCb        *ue
18720  *  @return   Void
18721  **/
18722 #ifdef ANSI
18723 PUBLIC Void rgSCHCmnUlUeFillAllocInfo
18724 (
18725 RgSchCellCb      *cell,
18726 RgSchUeCb        *ue
18727 )
18728 #else
18729 PUBLIC Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
18730 RgSchCellCb      *cell;
18731 RgSchUeCb        *ue;
18732 #endif
18733 {
18734    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18735    RgSchCmnUeUlAlloc  *ulAllocInfo;
18736    RgSchCmnUlUe       *ueUl;
18737
18738    TRC2(rgSCHCmnUlUeFillAllocInfo);
18739
18740    ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18741    ulAllocInfo = &ueUl->alloc;
18742
18743    /* Fill alloc structure */
18744    rgSCHCmnUlAllocFillTpc(cell, ue, ulAllocInfo->alloc);
18745    rgSCHCmnUlAllocFillNdmrs(cellUl, ulAllocInfo->alloc);
18746    rgSCHCmnUlAllocLnkHqProc(ue, ulAllocInfo->alloc, ulAllocInfo->alloc->hqProc,
18747                      ulAllocInfo->alloc->hqProc->isRetx);
18748    /* Fill PDCCH */
18749    rgSCHCmnUlFillPdcchWithAlloc(ulAllocInfo->alloc->pdcch,
18750          ulAllocInfo->alloc, ue);
18751    /* Recording information about this allocation */
18752    rgSCHCmnUlRecordUeAlloc(cell, ue);
18753
18754    /* Update the UE's outstanding allocation */
18755    if (!ulAllocInfo->alloc->hqProc->isRetx)
18756    {
18757       rgSCHCmnUlUpdOutStndAlloc(cell, ue, ulAllocInfo->allocdBytes);
18758    }
18759
18760    RETVOID;
18761 }
18762
18763 /**
18764  * @brief Update the UEs outstanding alloc based on the BSR report's timing.
18765  *
18766  *
18767  * @details
18768  *
18769  *     Function: rgSCHCmnUpdUlCompEffBsr
18770  *     Purpose:  Clear off all the allocations from outstanding allocation that
18771  *     are later than or equal to BSR timing information (stored in UEs datIndTime).
18772  *
18773  *     Invoked by: Scheduler
18774  *
18775  *  @param[in]  RgSchUeCb *ue
18776  *  @return  Void
18777  **/
18778 #ifdef ANSI
18779 PRIVATE Void rgSCHCmnUpdUlCompEffBsr
18780 (
18781 RgSchUeCb *ue
18782 )
18783 #else
18784 PRIVATE Void rgSCHCmnUpdUlCompEffBsr(ue)
18785 RgSchUeCb *ue;
18786 #endif
18787 {
18788    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
18789    CmLList   *node = ueUl->ulAllocLst.last;
18790    RgSchCmnAllocRecord *allRcd;
18791    U32 outStndAlloc=0;
18792    U32 nonLcg0OutStndAllocBs=0;
18793    U32 nonLcg0Bsr=0;
18794    U8  lcgId;
18795    RgSchCmnLcg *cmnLcg = NULLP;
18796    TRC2(rgSCHCmnUpdUlCompEffBsr);
18797
18798    while (node)
18799    {
18800       allRcd = (RgSchCmnAllocRecord *)node->node;
18801       if (RGSCH_TIMEINFO_SAME(ue->macCeRptTime, allRcd->allocTime))
18802       {
18803          node = node->next;
18804          break;
18805       }
18806       node = node->prev;
18807    }
18808    while (node)
18809    {
18810       allRcd = (RgSchCmnAllocRecord *)node->node;
18811       node = node->next;
18812       outStndAlloc += allRcd->alloc;
18813    }
18814  
18815    cmnLcg = (RgSchCmnLcg *)(ue->ul.lcgArr[0].sch);
18816    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
18817    if (cmnLcg->bs > outStndAlloc)
18818    {
18819       cmnLcg->bs -= outStndAlloc;
18820       ue->ul.minReqBytes = cmnLcg->bs;
18821       outStndAlloc = 0;
18822    }
18823    else
18824    {
18825       nonLcg0OutStndAllocBs = outStndAlloc - cmnLcg->bs;
18826       cmnLcg->bs = 0;
18827    }
18828
18829    for(lcgId = 1;lcgId < RGSCH_MAX_LCG_PER_UE; lcgId++)
18830    {
18831       if(RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
18832       {
18833          cmnLcg = ((RgSchCmnLcg *) (ue->ul.lcgArr[lcgId].sch));
18834          if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
18835          {
18836             nonLcg0Bsr += cmnLcg->bs;
18837          }
18838       }
18839    }
18840    nonLcg0Bsr += ue->ul.nonGbrLcgBs;  
18841    if (nonLcg0OutStndAllocBs > nonLcg0Bsr)
18842    {
18843       nonLcg0Bsr = 0;
18844    }
18845    else
18846    {
18847       nonLcg0Bsr -= nonLcg0OutStndAllocBs;
18848    }
18849    ue->ul.nonLcg0Bs = nonLcg0Bsr;
18850    /* Cap effBsr with nonLcg0Bsr and append lcg0 bs.
18851     * nonLcg0Bsr limit applies only to lcg1,2,3 */
18852    /* better be handled in individual scheduler */
18853    ue->ul.effBsr = nonLcg0Bsr +\
18854                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
18855    RETVOID;
18856 }
18857
18858 /**
18859  * @brief  Records information about the current allocation.
18860  *
18861  * @details
18862  *
18863  *     Function: rgSCHCmnUlRecordUeAlloc
18864  *     Purpose:  Records information about the curent allocation.
18865  *               This includes the allocated bytes, as well
18866  *               as some power information.
18867  *
18868  *     Invoked by: Scheduler
18869  *
18870  *  @param[in]  RgSchCellCb *cell
18871  *  @param[in]  RgSchUeCb   *ue
18872  *  @return  Void
18873  **/
18874 #ifdef ANSI
18875 PUBLIC Void rgSCHCmnUlRecordUeAlloc
18876 (
18877 RgSchCellCb *cell,
18878 RgSchUeCb   *ue
18879 )
18880 #else
18881 PUBLIC Void rgSCHCmnUlRecordUeAlloc(cell, ue)
18882 RgSchCellCb *cell;
18883 RgSchUeCb   *ue;
18884 #endif
18885 {
18886 #ifdef LTE_TDD
18887    RgSchCmnUlCell     *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
18888 #endif
18889    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18890    CmLListCp           *lst = &ueUl->ulAllocLst;
18891    CmLList             *node = ueUl->ulAllocLst.first;
18892    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18893    RgSchCmnUeUlAlloc  *ulAllocInfo = &ueUl->alloc;
18894    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
18895    TRC2(rgSCHCmnUlRecordUeAlloc);
18896
18897    cmLListDelFrm(lst, &allRcd->lnk);
18898 #ifndef LTE_TDD
18899    /* To the crntTime, add the MIN time at which UE will
18900     * actually send the BSR i.e DELTA+4 */
18901    allRcd->allocTime = cell->crntTime;
18902    /*ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
18903 #ifdef EMTC_ENABLE
18904    if(ue->isEmtcUe == TRUE)
18905    {
18906       RGSCH_INCR_SUB_FRAME_EMTC(allRcd->allocTime,
18907                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18908    }
18909    else
18910 #endif
18911    {
18912       RGSCH_INCR_SUB_FRAME(allRcd->allocTime,
18913                            (TFU_ULCNTRL_DLDELTA + RGSCH_PDCCH_PUSCH_DELTA));
18914    }
18915 #else
18916    allRcd->allocTime = cellUl->schdTime;
18917 #endif
18918    cmLListAdd2Tail(lst, &allRcd->lnk);
18919
18920    /* Filling in the parameters to be recorded */
18921    allRcd->alloc = ulAllocInfo->allocdBytes;
18922    //allRcd->numRb = ulAllocInfo->alloc->grnt.numRb;
18923    allRcd->numRb = (ulAllocInfo->alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
18924    /*Recording the UL CQI derived from the maxUlCqi */
18925    allRcd->cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
18926    allRcd->tpc   = ulAllocInfo->alloc->grnt.tpc;
18927
18928    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18929
18930    cell->measurements.ulBytesCnt += ulAllocInfo->allocdBytes;
18931
18932    RETVOID;
18933 }
18934
18935 /** PHR handling for MSG3
18936  * @brief  Records allocation information of msg3 in the the UE.
18937  *
18938  * @details
18939  *
18940  *     Function: rgSCHCmnUlRecMsg3Alloc
18941  *     Purpose:  Records information about msg3 allocation.
18942  *               This includes the allocated bytes, as well
18943  *               as some power information.
18944  *
18945  *     Invoked by: Scheduler
18946  *
18947  *  @param[in]  RgSchCellCb *cell
18948  *  @param[in]  RgSchUeCb   *ue
18949  *  @param[in]  RgSchRaCb   *raCb
18950  *  @return  Void
18951  **/
18952 #ifdef ANSI
18953 PUBLIC Void rgSCHCmnUlRecMsg3Alloc
18954 (
18955 RgSchCellCb *cell,
18956 RgSchUeCb   *ue,
18957 RgSchRaCb   *raCb
18958 )
18959 #else
18960 PUBLIC Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
18961 RgSchCellCb *cell;
18962 RgSchUeCb   *ue;
18963 RgSchRaCb   *raCb;
18964 #endif
18965 {
18966    RgSchCmnUlUe        *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
18967    CmLListCp           *lst = &ueUl->ulAllocLst;
18968    CmLList             *node = ueUl->ulAllocLst.first;
18969    RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
18970
18971    /* Stack Crash problem for TRACE5 changes */
18972    TRC2(rgSCHCmnUlRecMsg3Alloc);
18973
18974    cmLListDelFrm(lst, node);
18975    allRcd->allocTime = raCb->msg3AllocTime;
18976    cmLListAdd2Tail(lst, node);
18977
18978    /* Filling in the parameters to be recorded */
18979    allRcd->alloc = raCb->msg3Grnt.datSz;
18980    allRcd->numRb = raCb->msg3Grnt.numRb;
18981    allRcd->cqi   = raCb->ccchCqi;
18982    allRcd->tpc   = raCb->msg3Grnt.tpc;
18983
18984    rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
18985
18986    RETVOID;
18987 }
18988 /**
18989  * @brief Keeps track of the most recent RG_SCH_CMN_MAX_ALLOC_TRACK
18990  * allocations to track. Adds this allocation to the ueUl's ulAllocLst.
18991  *
18992  *
18993  * @details
18994  *
18995  *     Function: rgSCHCmnUlUpdOutStndAlloc
18996  *     Purpose:  Recent Allocation shall be at First Pos'n.
18997  *               Remove the last node, update the fields
18998  *                with the new allocation and add at front.
18999  *
19000  *     Invoked by: Scheduler
19001  *
19002  *  @param[in]  RgSchCellCb *cell
19003  *  @param[in]  RgSchUeCb   *ue
19004  *  @param[in]  U32 alloc
19005  *  @return  Void
19006  **/
19007 #ifdef ANSI
19008 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc
19009 (
19010 RgSchCellCb *cell,
19011 RgSchUeCb   *ue,
19012 U32 alloc
19013 )
19014 #else
19015 PUBLIC Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
19016 RgSchCellCb *cell;
19017 RgSchUeCb   *ue;
19018 U32 alloc;
19019 #endif
19020 {
19021    U32                 nonLcg0Alloc=0;
19022    TRC2(rgSCHCmnUlUpdOutStndAlloc);
19023
19024    /* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
19025    if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
19026    {
19027       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs -= alloc;
19028    }
19029    else
19030    {
19031       nonLcg0Alloc = alloc - ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19032       ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs = 0;
19033    }
19034
19035    if (nonLcg0Alloc >= ue->ul.nonLcg0Bs)
19036    {
19037       ue->ul.nonLcg0Bs  = 0;
19038    }
19039    else
19040    {
19041       ue->ul.nonLcg0Bs  -= nonLcg0Alloc;
19042    }
19043    /* Cap effBsr with effAmbr and append lcg0 bs.
19044     * effAmbr limit applies only to lcg1,2,3 non GBR LCG's*/
19045    /* better be handled in individual scheduler */
19046    ue->ul.effBsr = ue->ul.nonLcg0Bs +\
19047                   ((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
19048 #ifdef RGR_V1
19049    if (ue->ul.effBsr == 0)
19050    {
19051       if (ue->bsrTmr.tmrEvnt != TMR_NONE)
19052       {
19053          rgSCHTmrStopTmr(cell, ue->bsrTmr.tmrEvnt, ue);
19054       }
19055       /* ccpu00133008 */
19056       if (FALSE == ue->isSrGrant)
19057       {
19058          if (ue->ul.bsrTmrCfg.isPrdBsrTmrPres)
19059          {
19060             /*
19061             rgSCHTmrStartTmr(cell, ue, RG_SCH_TMR_BSR,
19062                   ue->ul.bsrTmrCfg.prdBsrTmr);
19063             */
19064          }
19065       }
19066    }
19067 #endif
19068    /* Resetting UEs lower Cap */
19069    ue->ul.minReqBytes = 0;
19070
19071    RETVOID;
19072 }
19073
19074
19075 /**
19076  * @brief Returns the "Itbs" for a given UE.
19077  *
19078  * @details
19079  *
19080  *     Function: rgSCHCmnUlGetITbs
19081  *     Purpose:  This function returns the "Itbs" for a given UE.
19082  *
19083  *     Invoked by: Scheduler
19084  *
19085  *  @param[in]  RgSchUeCb        *ue
19086  *  @return     U8
19087  **/
19088 #ifdef ANSI
19089 PUBLIC U8 rgSCHCmnUlGetITbs
19090 (
19091 RgSchCellCb      *cell,
19092 RgSchUeCb        *ue,
19093 Bool             isEcp
19094 )
19095 #else
19096 PUBLIC U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
19097 RgSchCellCb      *cell;
19098 RgSchUeCb        *ue;
19099 Bool             isEcp;
19100 #endif
19101 {
19102    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
19103    /* CQI will be capped to maxUlCqi for 16qam UEs */
19104    CmLteUeCategory  ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
19105    U8            cqi;
19106 #ifdef UL_LA
19107    S32            iTbs;
19108    U8            maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi]; 
19109 #endif
19110
19111    TRC2(rgSCHCmnUlGetITbs);
19112
19113    /* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
19114 #ifdef TFU_UPGRADE
19115    if ( (ueCtgy != CM_LTE_UE_CAT_5) &&
19116         (ueUl->validUlCqi > ueUl->maxUlCqi)
19117       )
19118    {
19119       cqi = ueUl->maxUlCqi;
19120    }
19121    else
19122    {
19123       cqi = ueUl->validUlCqi;
19124    }
19125
19126 #ifdef UL_LA
19127    iTbs = (ueUl->ulLaCb.cqiBasediTbs + ueUl->ulLaCb.deltaiTbs)/100;
19128
19129    RG_SCH_CHK_ITBS_RANGE(iTbs, maxiTbs); 
19130
19131    iTbs = RGSCH_MIN(iTbs,  ue->cell->thresholds.maxUlItbs);
19132
19133 #ifdef LTE_TDD
19134    /* This is a Temp fix, done for TENBPLUS-3898, ULSCH SDU corruption
19135       was seen when IMCS exceeds 20 on T2k TDD */
19136    if (iTbs > 19)
19137    {
19138       iTbs = 19;
19139    }
19140 #endif
19141    RETVALUE(iTbs);
19142 #endif 
19143 #else
19144    if ( (ueCtgy != CM_LTE_UE_CAT_5) && (ueUl->crntUlCqi[0] > ueUl->maxUlCqi ))
19145    {
19146       cqi = ueUl->maxUlCqi;
19147    }
19148    else
19149    {
19150       cqi = ueUl->crntUlCqi[0];
19151    }
19152 #endif
19153    RETVALUE(rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
19154 }
19155
19156 /**
19157  * @brief This function adds the UE to DLRbAllocInfo TX lst.
19158  *
19159  * @details
19160  *
19161  *     Function: rgSCHCmnDlRbInfoAddUeTx
19162  *     Purpose:  This function adds the UE to DLRbAllocInfo TX lst.
19163  *
19164  *     Invoked by: Common Scheduler
19165  *
19166  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19167  *  @param[in]  RgSchUeCb             *ue
19168  *  @param[in]  RgSchDlHqProcCb       *hqP
19169  *  @return  Void
19170  *
19171  **/
19172 #ifdef ANSI
19173 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx
19174 (
19175 RgSchCellCb        *cell,
19176 RgSchCmnDlRbAllocInfo *allocInfo,
19177 RgSchUeCb             *ue,
19178 RgSchDlHqProcCb       *hqP
19179 )
19180 #else
19181 PRIVATE Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
19182 RgSchCellCb        *cell;
19183 RgSchCmnDlRbAllocInfo *allocInfo;
19184 RgSchUeCb             *ue;
19185 RgSchDlHqProcCb       *hqP;
19186 #endif
19187 {
19188    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
19189
19190    TRC2(rgSCHCmnDlRbInfoAddUeTx);
19191
19192    if (hqP->reqLnk.node == NULLP)
19193    {
19194       if (cellSch->dl.isDlFreqSel)
19195       {
19196          cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19197            &allocInfo->dedAlloc.txHqPLst, hqP);
19198       }
19199       else
19200       {
19201          {
19202             cmLListAdd2Tail(&allocInfo->dedAlloc.txHqPLst, &hqP->reqLnk);
19203          }
19204          hqP->reqLnk.node = (PTR)hqP;
19205       }
19206    }
19207    RETVOID;
19208 }
19209
19210 /**
19211  * @brief This function adds the UE to DLRbAllocInfo RETX lst.
19212  *
19213  * @details
19214  *
19215  *     Function: rgSCHCmnDlRbInfoAddUeRetx
19216  *     Purpose:  This function adds the UE to DLRbAllocInfo RETX lst.
19217  *
19218  *     Invoked by: Common Scheduler
19219  *
19220  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19221  *  @param[in]  RgSchUeCb             *ue
19222  *  @param[in]  RgSchDlHqProcCb       *hqP
19223  *  @return  Void
19224  *
19225  **/
19226 #ifdef ANSI
19227 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx
19228 (
19229 RgSchCellCb        *cell,
19230 RgSchCmnDlRbAllocInfo *allocInfo,
19231 RgSchUeCb             *ue,
19232 RgSchDlHqProcCb       *hqP
19233 )
19234 #else
19235 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
19236 RgSchCellCb        *cell;
19237 RgSchCmnDlRbAllocInfo *allocInfo;
19238 RgSchUeCb             *ue;
19239 RgSchDlHqProcCb       *hqP;
19240 #endif
19241 {
19242    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19243
19244    TRC2(rgSCHCmnDlRbInfoAddUeRetx);
19245
19246    if (cellSch->dl.isDlFreqSel)
19247    {
19248       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19249         &allocInfo->dedAlloc.retxHqPLst, hqP);
19250    }
19251    else
19252    {
19253       /* checking UE's presence in this lst is unnecessary */
19254       cmLListAdd2Tail(&allocInfo->dedAlloc.retxHqPLst, &hqP->reqLnk);
19255       hqP->reqLnk.node = (PTR)hqP;
19256    }
19257    RETVOID;
19258 }
19259
19260 /**
19261  * @brief This function adds the UE to DLRbAllocInfo TX-RETX lst.
19262  *
19263  * @details
19264  *
19265  *     Function: rgSCHCmnDlRbInfoAddUeRetxTx
19266  *     Purpose:  This adds the UE to DLRbAllocInfo TX-RETX lst.
19267  *
19268  *     Invoked by: Common Scheduler
19269  *
19270  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19271  *  @param[in]  RgSchUeCb             *ue
19272  *  @param[in]  RgSchDlHqProcCb       *hqP
19273  *  @return  Void
19274  *
19275  **/
19276 #ifdef ANSI
19277 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx
19278 (
19279 RgSchCellCb        *cell,
19280 RgSchCmnDlRbAllocInfo *allocInfo,
19281 RgSchUeCb             *ue,
19282 RgSchDlHqProcCb       *hqP
19283 )
19284 #else
19285 PRIVATE Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
19286 RgSchCellCb        *cell;
19287 RgSchCmnDlRbAllocInfo *allocInfo;
19288 RgSchUeCb             *ue;
19289 RgSchDlHqProcCb       *hqP;
19290 #endif
19291 {
19292    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
19293
19294    TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
19295
19296    if (cellSch->dl.isDlFreqSel)
19297    {
19298       cellSch->apisDlfs->rgSCHDlfsAddUeToLst(cell,
19299         &allocInfo->dedAlloc.txRetxHqPLst, hqP);
19300    }
19301    else
19302    {
19303       cmLListAdd2Tail(&allocInfo->dedAlloc.txRetxHqPLst, &hqP->reqLnk);
19304       hqP->reqLnk.node = (PTR)hqP;
19305    }
19306    RETVOID;
19307 }
19308
19309 /**
19310  * @brief This function adds the UE to DLRbAllocInfo NonSchdRetxLst.
19311  *
19312  * @details
19313  *
19314  *     Function: rgSCHCmnDlAdd2NonSchdRetxLst 
19315  *     Purpose:  During RB estimation for RETX, if allocation fails
19316  *               then appending it to NonSchdRetxLst, the further
19317  *               action is taken as part of Finalization in
19318  *               respective schedulers.
19319  *
19320  *     Invoked by: Common Scheduler
19321  *
19322  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19323  *  @param[in]  RgSchUeCb             *ue
19324  *  @param[in]  RgSchDlHqProcCb       *hqP
19325  *  @return  Void
19326  *
19327  **/
19328 #ifdef ANSI
19329 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst 
19330 (
19331 RgSchCmnDlRbAllocInfo *allocInfo,
19332 RgSchUeCb             *ue,
19333 RgSchDlHqProcCb       *hqP
19334 )
19335 #else
19336 PRIVATE Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
19337 RgSchCmnDlRbAllocInfo *allocInfo;
19338 RgSchUeCb             *ue;
19339 RgSchDlHqProcCb       *hqP;
19340 #endif
19341 {
19342    CmLList         *schdLnkNode;
19343
19344    TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
19345
19346 #ifdef LTEMAC_SPS
19347    if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) && 
19348          (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP)))
19349    {
19350       RETVOID;
19351    }
19352 #endif
19353
19354    schdLnkNode = &hqP->schdLstLnk;
19355    RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
19356    cmLListAdd2Tail(&allocInfo->dedAlloc.nonSchdRetxHqPLst, schdLnkNode);
19357
19358    RETVOID;
19359 }
19360
19361
19362
19363 /**
19364  * @brief This function adds the UE to DLRbAllocInfo NonSchdTxRetxLst.
19365  *
19366  * @details
19367  *
19368  *     Function: rgSCHCmnDlAdd2NonSchdTxRetxLst 
19369  *     Purpose:  During RB estimation for TXRETX, if allocation fails
19370  *               then appending it to NonSchdTxRetxLst, the further
19371  *               action is taken as part of Finalization in
19372  *               respective schedulers.
19373  *
19374  *     Invoked by: Common Scheduler
19375  *
19376  *  @param[out] RgSchCmnDlRbAllocInfo *allocInfo
19377  *  @param[in]  RgSchUeCb             *ue
19378  *  @param[in]  RgSchDlHqProcCb       *hqP
19379  *  @return  Void
19380  *
19381  **/
19382 #ifdef LTE_TDD
19383 /**
19384  * @brief This function handles the initialisation of DL HARQ/ACK feedback
19385  *        timing information for eaach DL subframe.
19386  *
19387  * @details
19388  *
19389  *     Function: rgSCHCmnDlANFdbkInit
19390  *     Purpose:  Each DL subframe stores the sfn and subframe
19391  *               information of UL subframe in which it expects
19392  *               HARQ ACK/NACK feedback for this subframe.It
19393  *               generates the information based on Downlink
19394  *               Association Set Index table.
19395  *
19396  *     Invoked by: Scheduler
19397  *
19398  *  @param[in]  RgSchCellCb*     cell
19399  *  @return     S16
19400  *
19401  **/
19402 #ifdef ANSI
19403 PRIVATE S16 rgSCHCmnDlANFdbkInit
19404 (
19405 RgSchCellCb                *cell
19406 )
19407 #else
19408 PRIVATE S16 rgSCHCmnDlANFdbkInit(cell)
19409 RgSchCellCb                *cell;
19410 #endif
19411 {
19412  U8                   sfCount;
19413  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19414  U8                   maxDlSubfrms = cell->numDlSubfrms;
19415  U8                   sfNum;
19416  U8                   idx;
19417  U8                   dlIdx;
19418  U8                   calcSfnOffset;
19419  S8                   calcSfNum;
19420  U8                   ulSfCnt =0;
19421  RgSchTddSubfrmInfo   ulSubfrmInfo;
19422  U8                   maxUlSubfrms;
19423
19424    TRC2(rgSCHCmnDlANFdbkInit);
19425
19426    ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19427    maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19428
19429    /* Generate HARQ ACK/NACK feedback information for each DL sf in a radio frame
19430     * Calculate this information based on DL Association set Index table */
19431    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19432    {
19433       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19434             RG_SCH_TDD_UL_SUBFRAME)
19435       {
19436          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19437       }
19438       ulSfCnt++;
19439
19440       for(idx=0; idx < rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19441             numFdbkSubfrms; idx++)
19442       {
19443          calcSfNum = sfNum - rgSchTddDlAscSetIdxKTbl[ulDlCfgIdx][sfNum].\
19444                      subfrmNum[idx];
19445          if(calcSfNum < 0)
19446          {
19447             calcSfnOffset = RGSCH_CEIL(-calcSfNum, RGSCH_NUM_SUB_FRAMES);
19448          }
19449          else
19450          {
19451             calcSfnOffset = 0;
19452          }
19453
19454          calcSfNum = ((RGSCH_NUM_SUB_FRAMES * calcSfnOffset) + calcSfNum)\
19455                      % RGSCH_NUM_SUB_FRAMES;
19456
19457          if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19458          {
19459             dlIdx = calcSfNum;
19460          }
19461          else if((ulSubfrmInfo.switchPoints == 2) && (calcSfNum <= \
19462                   RG_SCH_CMN_SPL_SUBFRM_6))
19463          {
19464             dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19465          }
19466          else
19467          {
19468             dlIdx = calcSfNum - maxUlSubfrms;
19469          }
19470
19471          cell->subFrms[dlIdx]->dlFdbkInfo.subframe = sfNum;
19472          cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = calcSfnOffset;
19473          cell->subFrms[dlIdx]->dlFdbkInfo.m = idx;
19474       }
19475       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19476    }
19477
19478    /* DL subframes in the subsequent radio frames are initialized
19479     * with the previous radio frames  */
19480    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;\
19481          dlIdx++)
19482    {
19483       sfNum = dlIdx - rgSchTddNumDlSubfrmTbl[ulDlCfgIdx]\
19484               [RGSCH_NUM_SUB_FRAMES-1];
19485       cell->subFrms[dlIdx]->dlFdbkInfo.subframe = \
19486                                                   cell->subFrms[sfNum]->dlFdbkInfo.subframe;
19487       cell->subFrms[dlIdx]->dlFdbkInfo.sfnOffset = \
19488                                                    cell->subFrms[sfNum]->dlFdbkInfo.sfnOffset;
19489       cell->subFrms[dlIdx]->dlFdbkInfo.m = cell->subFrms[sfNum]->dlFdbkInfo.m;
19490    }
19491    RETVALUE(ROK);
19492 }
19493
19494 /**
19495  * @brief This function handles the initialization of uplink association
19496  *        set information for each DL subframe.
19497  *
19498  *
19499  * @details
19500  *
19501  *     Function: rgSCHCmnDlKdashUlAscInit
19502  *     Purpose:  Each DL sf stores the sfn and sf information of UL sf
19503  *               in which it expects HQ ACK/NACK trans. It generates the information
19504  *               based on k` in UL association set index table.
19505  *
19506  *     Invoked by: Scheduler
19507  *
19508  *  @param[in]  RgSchCellCb*     cell
19509  *  @return     S16
19510  *
19511  **/
19512 #ifdef ANSI
19513 PRIVATE S16 rgSCHCmnDlKdashUlAscInit
19514 (
19515 RgSchCellCb                *cell
19516 )
19517 #else
19518 PRIVATE S16 rgSCHCmnDlKdashUlAscInit(cell)
19519 RgSchCellCb                *cell;
19520 #endif
19521 {
19522  U8                   sfCount;
19523  U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19524  U8                   maxDlSubfrms = cell->numDlSubfrms;
19525  U8                   sfNum;
19526  U8                   dlIdx;
19527  S8                   calcSfnOffset;
19528  S8                   calcSfNum;
19529  U8                   ulSfCnt =0;
19530  RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19531  U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19532                                      [RGSCH_NUM_SUB_FRAMES-1];
19533  U8                   dlPres = 0;
19534
19535    TRC2(rgSCHCmnDlKdashUlAscInit);
19536
19537    /* Generate ACK/NACK offset information for each DL subframe in a radio frame
19538     * Calculate this information based on K` in UL Association Set table */
19539    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19540    {
19541       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19542             RG_SCH_TDD_UL_SUBFRAME)
19543       {
19544          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19545       }
19546       ulSfCnt++;
19547
19548       calcSfNum = (sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum] + \
19549             RGSCH_NUM_SUB_FRAMES) % RGSCH_NUM_SUB_FRAMES;
19550       calcSfnOffset = sfNum - rgSchTddUlAscIdxKDashTbl[ulDlCfgIdx-1][sfNum];
19551       if(calcSfnOffset < 0)
19552       {
19553          calcSfnOffset = RGSCH_CEIL(-calcSfnOffset, RGSCH_NUM_SUB_FRAMES);
19554       }
19555       else
19556       {
19557          calcSfnOffset = 0;
19558       }
19559
19560       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19561       {
19562          dlIdx = calcSfNum;
19563       }
19564       else if((ulSubfrmInfo.switchPoints == 2) &&
19565             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19566       {
19567          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19568       }
19569       else
19570       {
19571          dlIdx = calcSfNum - maxUlSubfrms;
19572       }
19573
19574       cell->subFrms[dlIdx]->ulAscInfo.subframe = sfNum;
19575       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset = calcSfnOffset;
19576
19577       /* set dlIdx for which ulAscInfo is updated */
19578       dlPres = dlPres | (1 << dlIdx);
19579       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19580    }
19581
19582    /* Set Invalid information for which ulAscInfo is not present */
19583    for (sfCount = 0;
19584          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19585          sfCount++)
19586    {
19587       /* If dlPres is 0, ulAscInfo is not present in that DL index */
19588       if(! ((dlPres >> sfCount)&0x01))
19589       {
19590          cell->subFrms[sfCount]->ulAscInfo.sfnOffset =
19591             RGSCH_INVALID_INFO;
19592          cell->subFrms[sfCount]->ulAscInfo.subframe =
19593             RGSCH_INVALID_INFO;
19594       }
19595    }
19596
19597    /* DL subframes in the subsequent radio frames are initialized
19598     * with the previous radio frames  */
19599    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms; dlIdx < maxDlSubfrms;
19600          dlIdx++)
19601    {
19602       sfNum = dlIdx - \
19603               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19604       cell->subFrms[dlIdx]->ulAscInfo.subframe =
19605          cell->subFrms[sfNum]->ulAscInfo.subframe;
19606       cell->subFrms[dlIdx]->ulAscInfo.sfnOffset =
19607          cell->subFrms[sfNum]->ulAscInfo.sfnOffset;
19608    }
19609    RETVALUE(ROK);
19610 }
19611
19612
19613 /**
19614  * @brief This function initialises the 'Np' value for 'p'
19615  *
19616  * @details
19617  *
19618  *     Function: rgSCHCmnDlNpValInit
19619  *     Purpose:  To initialise the 'Np' value for each 'p'. It is used
19620  *               to find the mapping between nCCE and 'p' and used in
19621  *               HARQ ACK/NACK reception.
19622  *
19623  *     Invoked by: Scheduler
19624  *
19625  *  @param[in]  RgSchCellCb*     cell
19626  *  @return     S16
19627  *
19628  **/
19629 #ifdef ANSI
19630 PRIVATE S16 rgSCHCmnDlNpValInit
19631 (
19632 RgSchCellCb                *cell
19633 )
19634 #else
19635 PRIVATE S16 rgSCHCmnDlNpValInit(cell)
19636 RgSchCellCb                *cell;
19637 #endif
19638 {
19639    U8    idx;
19640    U16   np;
19641    TRC2(rgSCHCmnDlNpValInit);
19642
19643    /* Always Np is 0 for p=0 */
19644    cell->rgSchTddNpValTbl[0] = 0;
19645
19646    for(idx=1; idx < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; idx++)
19647    {
19648       np = cell->bwCfg.dlTotalBw * (idx * RG_SCH_CMN_NUM_SUBCAR - 4);
19649       cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
19650    }
19651
19652    RETVALUE(ROK);
19653 }
19654
19655 /**
19656  * @brief This function handles the creation of RACH preamble
19657  *        list to queue the preambles and process at the scheduled
19658  *        time.
19659  *
19660  * @details
19661  *
19662  *     Function: rgSCHCmnDlCreateRachPrmLst
19663  *     Purpose:  To create RACH preamble list based on RA window size.
19664  *               It is used to queue the preambles and process it at the
19665  *               scheduled time.
19666  *
19667  *     Invoked by: Scheduler
19668  *
19669  *  @param[in]  RgSchCellCb*     cell
19670  *  @return     S16
19671  *
19672  **/
19673 #ifdef ANSI
19674 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst
19675 (
19676 RgSchCellCb                *cell
19677 )
19678 #else
19679 PRIVATE S16 rgSCHCmnDlCreateRachPrmLst(cell)
19680 RgSchCellCb                *cell;
19681 #endif
19682 {
19683  U8       raArrSz;
19684  S16       ret;
19685  U8       lstSize;
19686
19687    TRC2(rgSCHCmnDlCreateRachPrmLst);
19688
19689    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19690
19691    lstSize = raArrSz * RGSCH_MAX_RA_RNTI_PER_SUBFRM * RGSCH_NUM_SUB_FRAMES;
19692
19693    cell->raInfo.maxRaSize = raArrSz;
19694    ret = rgSCHUtlAllocSBuf(cell->instIdx,
19695          (Data **)(&cell->raInfo.raReqLst), (Size)(lstSize * sizeof(CmLListCp)));
19696    if (ret != ROK)
19697    {
19698       RETVALUE(ret);
19699    }
19700
19701    cell->raInfo.lstSize = lstSize;
19702
19703    RETVALUE(ROK);
19704 }
19705
19706
19707 /**
19708  * @brief This function handles the initialization of RACH Response
19709  *        information at each DL subframe.
19710  *
19711  * @details
19712  *
19713  *     Function: rgSCHCmnDlRachInfoInit
19714  *     Purpose:  Each DL subframe stores the sfn and subframe information of
19715  *               possible RACH response allowed for UL subframes. It generates
19716  *               the information based on PRACH configuration.
19717  *
19718  *     Invoked by: Scheduler
19719  *
19720  *  @param[in]  RgSchCellCb*     cell
19721  *  @return     S16
19722  *
19723  **/
19724 #ifdef ANSI
19725 PRIVATE S16 rgSCHCmnDlRachInfoInit
19726 (
19727 RgSchCellCb                *cell
19728 )
19729 #else
19730 PRIVATE S16 rgSCHCmnDlRachInfoInit(cell)
19731 RgSchCellCb                *cell;
19732 #endif
19733 {
19734    U8                   sfCount;
19735    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19736    U8                   sfNum;
19737    U8                   ulSfCnt =0;
19738    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19739                                        [RGSCH_NUM_SUB_FRAMES-1];
19740    U8                   raArrSz;
19741    RgSchTddRachRspLst   rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
19742    U8                   startWin;
19743    U8                   endWin;
19744    U8                   sfnIdx;
19745    U8                   subfrmIdx;
19746    U8                   endSubfrmIdx;
19747    U8                   startSubfrmIdx;
19748    S16                   ret;
19749    RgSchTddRachDelInfo  *delInfo;
19750    S8                   sfnOffset;
19751    U8                   numSubfrms;
19752
19753    TRC2(rgSCHCmnDlRachInfoInit);
19754
19755    cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
19756
19757    RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
19758
19759    /* Include Special subframes */
19760    maxUlSubfrms = maxUlSubfrms + \
19761                   rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx].switchPoints;
19762    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19763    {
19764       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] ==
19765             RG_SCH_TDD_DL_SUBFRAME)
19766       {
19767          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19768       }
19769       ulSfCnt++;
19770
19771       startWin = (sfNum + RG_SCH_CMN_RARSP_WAIT_PRD + \
19772             ((RgSchCmnCell *)cell->sc.sch)->dl.numRaSubFrms);
19773       endWin = (startWin + cell->rachCfg.raWinSize - 1);
19774       startSubfrmIdx =
19775          rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][startWin%RGSCH_NUM_SUB_FRAMES];
19776       /* Find the next DL subframe starting from Subframe 0 */
19777       if((startSubfrmIdx % RGSCH_NUM_SUB_FRAMES) == 0)
19778       {
19779          startWin = RGSCH_CEIL(startWin, RGSCH_NUM_SUB_FRAMES);
19780          startWin = startWin * RGSCH_NUM_SUB_FRAMES;
19781       }
19782
19783       endSubfrmIdx =
19784          rgSchTddLowDlSubfrmIdxTbl[ulDlCfgIdx][endWin%RGSCH_NUM_SUB_FRAMES];
19785       endWin = (endWin/RGSCH_NUM_SUB_FRAMES) * RGSCH_NUM_SUB_FRAMES \
19786                + endSubfrmIdx;
19787       if(startWin > endWin)
19788       {
19789          continue;
19790       }
19791       /* Find all the possible RACH Response transmission
19792        * time within the RA window size */
19793       startSubfrmIdx = startWin%RGSCH_NUM_SUB_FRAMES;
19794       for(sfnIdx = startWin/RGSCH_NUM_SUB_FRAMES;
19795             sfnIdx <= endWin/RGSCH_NUM_SUB_FRAMES; sfnIdx++)
19796       {
19797          if(sfnIdx == endWin/RGSCH_NUM_SUB_FRAMES)
19798          {
19799             endSubfrmIdx = endWin%RGSCH_NUM_SUB_FRAMES;
19800          }
19801          else
19802          {
19803             endSubfrmIdx = RGSCH_NUM_SUB_FRAMES-1;
19804          }
19805
19806          /* Find all the possible RACH Response transmission
19807           * time within radio frame */
19808          for(subfrmIdx = startSubfrmIdx;
19809                subfrmIdx <= endSubfrmIdx; subfrmIdx++)
19810          {
19811             if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][subfrmIdx] ==
19812                   RG_SCH_TDD_UL_SUBFRAME)
19813             {
19814                continue;
19815             }
19816             subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
19817             /* Find the next DL subframe starting from Subframe 0 */
19818             if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
19819             {
19820                break;
19821             }
19822             RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx], subfrmIdx);
19823             numSubfrms =
19824                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
19825             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset = sfnIdx;
19826             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].subframe[numSubfrms]
19827                = sfNum;
19828             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms++;
19829          }
19830          startSubfrmIdx = RG_SCH_CMN_SUBFRM_0;
19831       }
19832       /* Update the subframes to be deleted at this subframe */
19833       /* Get the subframe after the end of RA window size */
19834       endWin++;
19835       endSubfrmIdx++;
19836       sfnOffset = endWin/RGSCH_NUM_SUB_FRAMES;
19837       if(sfnOffset < 0)
19838       {
19839          sfnOffset += raArrSz;
19840       }
19841       sfnIdx = (endWin/RGSCH_NUM_SUB_FRAMES) % raArrSz;
19842
19843       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx],endSubfrmIdx-1);
19844       if((endSubfrmIdx == RGSCH_NUM_SUB_FRAMES) ||
19845             (rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx] ==
19846              RGSCH_NUM_SUB_FRAMES))
19847       {
19848          subfrmIdx =
19849             rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][RG_SCH_CMN_SUBFRM_0];
19850       }
19851       else
19852       {
19853          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][endSubfrmIdx];
19854       }
19855
19856       delInfo = &rachRspLst[sfnIdx][subfrmIdx].delInfo;
19857       delInfo->sfnOffset = sfnOffset;
19858       delInfo->subframe[delInfo->numSubfrms] = sfNum;
19859       delInfo->numSubfrms++;
19860
19861       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19862    }
19863
19864    ret = rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz);
19865    if (ret != ROK)
19866    {
19867       RETVALUE(ret);
19868    }
19869
19870    RETVALUE(ROK);
19871 }
19872
19873 /**
19874  * @brief This function handles the initialization of PHICH information
19875  *        for each DL subframe based on PHICH table.
19876  *
19877  * @details
19878  *
19879  *     Function: rgSCHCmnDlPhichOffsetInit
19880  *     Purpose:  Each DL subf stores the sfn and subf information of UL subframe
19881  *               for which it trnsmts PHICH in this subframe. It generates the information
19882  *               based on PHICH table.
19883  *
19884  *     Invoked by: Scheduler
19885  *
19886  *  @param[in]  RgSchCellCb*     cell
19887  *  @return     S16
19888  *
19889  **/
19890 #ifdef ANSI
19891 PRIVATE S16 rgSCHCmnDlPhichOffsetInit
19892 (
19893 RgSchCellCb                *cell
19894 )
19895 #else
19896 PRIVATE S16 rgSCHCmnDlPhichOffsetInit(cell)
19897 RgSchCellCb                *cell;
19898 #endif
19899 {
19900    U8                   sfCount;
19901    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
19902    U8                   maxDlSubfrms = cell->numDlSubfrms;
19903    U8                   sfNum;
19904    U8                   dlIdx;
19905    U8                   dlPres = 0;
19906    U8                   calcSfnOffset;
19907    U8                   calcSfNum;
19908    U8                   ulSfCnt =0;
19909    RgSchTddSubfrmInfo   ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
19910    U8                   maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
19911                                        [RGSCH_NUM_SUB_FRAMES-1];
19912
19913    TRC2(rgSCHCmnDlPhichOffsetInit);
19914
19915    /* Generate PHICH offset information for each DL subframe in a radio frame
19916     * Calculate this information based on K in PHICH table */
19917    for (sfCount = 0, sfNum = 0; sfCount < maxUlSubfrms; sfCount++)
19918    {
19919       while(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][sfNum] !=
19920             RG_SCH_TDD_UL_SUBFRAME)
19921       {
19922          sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19923       }
19924       ulSfCnt++;
19925
19926       calcSfNum = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) % \
19927                   RGSCH_NUM_SUB_FRAMES;
19928       calcSfnOffset = (rgSchTddKPhichTbl[ulDlCfgIdx][sfNum] + sfNum) / \
19929                       RGSCH_NUM_SUB_FRAMES;
19930
19931       if(calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_1)
19932       {
19933          dlIdx = calcSfNum;
19934       }
19935       else if((ulSubfrmInfo.switchPoints == 2) &&
19936             (calcSfNum <= RG_SCH_CMN_SPL_SUBFRM_6))
19937       {
19938          dlIdx = calcSfNum - ulSubfrmInfo.numFrmHf1;
19939       }
19940       else
19941       {
19942          dlIdx = calcSfNum - maxUlSubfrms;
19943       }
19944
19945       cell->subFrms[dlIdx]->phichOffInfo.subframe = sfNum;
19946       cell->subFrms[dlIdx]->phichOffInfo.numSubfrms = 1;
19947
19948       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset = calcSfnOffset;
19949
19950       /* set dlIdx for which phich offset is updated */
19951       dlPres = dlPres | (1 << dlIdx);
19952       sfNum = (sfNum+1) % RGSCH_NUM_SUB_FRAMES;
19953    }
19954
19955    /* Set Invalid information for which phich offset is not present */
19956    for (sfCount = 0;
19957          sfCount < rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19958          sfCount++)
19959    {
19960       /* If dlPres is 0, phich offset is not present in that DL index */
19961       if(! ((dlPres >> sfCount)&0x01))
19962       {
19963          cell->subFrms[sfCount]->phichOffInfo.sfnOffset =
19964             RGSCH_INVALID_INFO;
19965          cell->subFrms[sfCount]->phichOffInfo.subframe =
19966             RGSCH_INVALID_INFO;
19967          cell->subFrms[sfCount]->phichOffInfo.numSubfrms = 0;
19968       }
19969    }
19970
19971    /* DL subframes in the subsequent radio frames are
19972     * initialized with the previous radio frames  */
19973    for(dlIdx = RGSCH_NUM_SUB_FRAMES - maxUlSubfrms;
19974          dlIdx < maxDlSubfrms; dlIdx++)
19975    {
19976       sfNum = dlIdx - \
19977               rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
19978
19979       cell->subFrms[dlIdx]->phichOffInfo.subframe =
19980          cell->subFrms[sfNum]->phichOffInfo.subframe;
19981
19982       cell->subFrms[dlIdx]->phichOffInfo.sfnOffset =
19983          cell->subFrms[sfNum]->phichOffInfo.sfnOffset;
19984    }
19985    RETVALUE(ROK);
19986 }
19987
19988
19989 /**
19990  * @brief Updation of Sch vars per TTI.
19991  *
19992  * @details
19993  *
19994  *     Function: rgSCHCmnUpdVars
19995  *     Purpose:  Updation of Sch vars per TTI.
19996  *
19997  *  @param[in]  RgSchCellCb *cell
19998  *  @return  Void
19999  *
20000  **/
20001 #ifdef ANSI
20002 PUBLIC Void rgSCHCmnUpdVars
20003 (
20004 RgSchCellCb *cell
20005 )
20006 #else
20007 PUBLIC Void rgSCHCmnUpdVars(cell)
20008 RgSchCellCb *cell;
20009 #endif
20010 {
20011    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
20012    CmLteTimingInfo   timeInfo;
20013    U8                idx;
20014    U8                ulSubframe;
20015    U8                ulDlCfgIdx = cell->ulDlCfgIdx;
20016    U8                msg3Subfrm;
20017    U8                Mval;
20018    TRC2(rgSCHCmnUpdVars);
20019  
20020    /* ccpu00132654-ADD- Initializing all the indices in every subframe*/ 
20021    rgSCHCmnInitVars(cell);
20022
20023    idx = (cell->crntTime.slot + TFU_ULCNTRL_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20024    /* Calculate the UL scheduling subframe idx based on the 
20025       Pusch k table */
20026    if(rgSchTddPuschTxKTbl[ulDlCfgIdx][idx] != 0)
20027    {
20028       /* PUSCH transmission is based on offset from DL
20029        * PDCCH scheduling */
20030       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA); 
20031       ulSubframe = rgSchTddPuschTxKTbl[ulDlCfgIdx][timeInfo.subframe];
20032       /* Add the DCI-0 to PUSCH time to get the time of UL subframe */
20033       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, ulSubframe);
20034 #ifdef LTEMAC_SPS
20035       cellUl->schdTti = timeInfo.sfn * 10 + timeInfo.subframe;
20036 #endif
20037       /* Fetch the corresponding  UL subframe Idx in UL sf array */ 
20038       cellUl->schdIdx = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20039       /* Fetch the corresponding  UL Harq Proc ID */ 
20040       cellUl->schdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20041       cellUl->schdTime = timeInfo;
20042    }
20043    Mval = rgSchTddPhichMValTbl[ulDlCfgIdx][idx]; 
20044    if(Mval)
20045    {
20046       /* Fetch the tx time for DL HIDCI-0 */
20047       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo, TFU_ULCNTRL_DLDELTA);
20048       /* Fetch the corresponding n-k tx time of PUSCH */
20049       cellUl->hqFdbkIdx[0] = rgSCHCmnGetPhichUlSfIdx(&timeInfo, cell);
20050       /* Retx will happen according to the Pusch k table */
20051       cellUl->reTxIdx[0] = cellUl->schdIdx;
20052       
20053       if(ulDlCfgIdx == 0) 
20054       {
20055          /* Calculate the ReTxIdx corresponding to hqFdbkIdx[0] */
20056          cellUl->reTxIdx[0] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20057                                                 cellUl->hqFdbkIdx[0]);
20058          if(Mval == 2)
20059          {
20060             /* At Idx 1 store the UL SF adjacent(left) to the UL SF
20061                given at idx 0 */  
20062             cellUl->hqFdbkIdx[1] = (cellUl->hqFdbkIdx[0]-1 + 
20063                                    cellUl->numUlSubfrms) % cellUl->numUlSubfrms;
20064             /* Calculate the ReTxIdx corresponding to hqFdbkIdx[1] */
20065             cellUl->reTxIdx[1] = rgSchUtlCfg0ReTxIdx(cell,timeInfo,
20066                                                 cellUl->hqFdbkIdx[1]);
20067          }                               
20068       }
20069    }
20070
20071    idx = (cell->crntTime.slot + TFU_RECPREQ_DLDELTA) % RGSCH_NUM_SUB_FRAMES;
20072    if (rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] == RG_SCH_TDD_UL_SUBFRAME)
20073    {
20074       RGSCHCMNADDTOCRNTTIME(cell->crntTime, timeInfo, TFU_RECPREQ_DLDELTA)
20075       cellUl->rcpReqIdx   = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20076    }
20077    idx = (cell->crntTime.slot+RG_SCH_CMN_DL_DELTA) % RGSCH_NUM_SUB_FRAMES;
20078    
20079    /*[ccpu00134666]-MOD-Modify the check to schedule the RAR in
20080      special subframe */                       
20081    if(rgSchTddUlDlSubfrmTbl[ulDlCfgIdx][idx] != RG_SCH_TDD_UL_SUBFRAME)
20082    {
20083       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20084       msg3Subfrm = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20085       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, msg3Subfrm);
20086       cellUl->msg3SchdIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20087       cellUl->msg3SchdHqProcIdx = rgSCHCmnGetUlHqProcIdx(&timeInfo, cell);
20088    }
20089 #ifdef LTEMAC_SPS
20090    if(!rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][idx])
20091    {
20092       cellUl->spsUlRsrvIdx = RGSCH_INVALID_INFO;
20093    }
20094    else
20095    {
20096       /* introduce some reuse with above code? */
20097       U8    offst;
20098       RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
20099       //offst = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
20100       offst = rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][timeInfo.subframe];
20101       RGSCHCMNADDTOCRNTTIME(timeInfo, timeInfo, offst);
20102       cellUl->spsUlRsrvIdx     = rgSCHCmnGetUlSfIdx(&timeInfo, cell);
20103       /* The harq proc continues to be accessed and used the same delta before
20104        * actual data occurance, and hence use the same idx */
20105       cellUl->spsUlRsrvHqProcIdx = cellUl->schdHqProcIdx;
20106    }
20107 #endif
20108
20109    /* RACHO: update cmn sched specific RACH variables,
20110     * mainly the prachMaskIndex */
20111    rgSCHCmnUpdRachParam(cell);
20112
20113    RETVOID;
20114 }
20115
20116 /**
20117  * @brief To get 'p' value from nCCE.
20118  *
20119  * @details
20120  *
20121  *     Function: rgSCHCmnGetPValFrmCCE
20122  *     Purpose:  Gets 'p' value for HARQ ACK/NACK reception from CCE.
20123  *
20124  *  @param[in]  RgSchCellCb   *cell
20125  *  @param[in]  U8            cce
20126  *  @return U8
20127  *
20128  **/
20129 #ifdef ANSI
20130 PUBLIC U8  rgSCHCmnGetPValFrmCCE
20131 (
20132 RgSchCellCb *cell,
20133 U8          cce
20134 )
20135 #else
20136 PUBLIC U8  rgSCHCmnGetPValFrmCCE(cell, cce)
20137 RgSchCellCb *cell;
20138 U8          cce;
20139 #endif
20140 {
20141    U8 i;
20142    TRC2(rgSCHCmnGetPValFrmCCE);
20143
20144    for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
20145    {
20146       if(cce < cell->rgSchTddNpValTbl[i])
20147       {
20148          RETVALUE(i-1);
20149       }
20150    }
20151    RETVALUE(0);
20152 }
20153 #endif
20154
20155 /***********************************************************
20156  *
20157  *     Func : rgSCHCmnUlAdapRetx
20158  *
20159  *     Desc : Adaptive retransmission for an allocation.
20160  *
20161  *     Ret  :
20162  *
20163  *     Notes:
20164  *
20165  *     File :
20166  *
20167  **********************************************************/
20168 #ifdef ANSI
20169 PRIVATE Void rgSCHCmnUlAdapRetx
20170 (
20171 RgSchUlAlloc    *alloc,
20172 RgSchUlHqProcCb *proc
20173 )
20174 #else
20175 PRIVATE Void rgSCHCmnUlAdapRetx(alloc, proc)
20176 RgSchUlAlloc    *alloc;
20177 RgSchUlHqProcCb *proc;
20178 #endif
20179 {
20180    TRC2(rgSCHCmnUlAdapRetx);
20181
20182    rgSCHUhmRetx(proc, alloc);
20183 #ifndef RG_5GTF
20184    if (proc->rvIdx != 0)
20185    {
20186       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[proc->rvIdx];
20187    }
20188    else
20189 #endif
20190    {
20191       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
20192    }
20193    RETVOID;
20194 }
20195
20196 /**
20197  * @brief Scheduler invocation per TTI.
20198  *
20199  * @details
20200  *
20201  *     Function: rgSCHCmnHdlUlInactUes
20202  *     Purpose:
20203  *
20204  *     Invoked by: Common Scheduler
20205  *
20206  *  @param[in]  RgSchCellCb *cell
20207  *  @return  Void
20208  **/
20209 #ifdef ANSI
20210 PRIVATE Void rgSCHCmnHdlUlInactUes
20211 (
20212 RgSchCellCb  *cell
20213 )
20214 #else
20215 PRIVATE Void rgSCHCmnHdlUlInactUes(cell)
20216 RgSchCellCb  *cell;
20217 #endif
20218 {
20219    RgSchCmnCell  *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20220    CmLListCp     ulInactvLst;
20221    TRC2(rgSCHCmnHdlUlInactUes);
20222    /* Get a List of Inactv UEs for UL*/
20223    cmLListInit(&ulInactvLst);
20224
20225    /* Trigger Spfc Schedulers with Inactive UEs */
20226    rgSCHMeasGapANRepGetUlInactvUe (cell, &ulInactvLst);
20227    /* take care of this in UL retransmission */
20228    cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
20229
20230    RETVOID;
20231 }
20232
20233 /**
20234  * @brief Scheduler invocation per TTI.
20235  *
20236  * @details
20237  *
20238  *     Function: rgSCHCmnHdlDlInactUes
20239  *     Purpose:
20240  *
20241  *     Invoked by: Common Scheduler
20242  *
20243  *  @param[in]  RgSchCellCb *cell
20244  *  @return  Void
20245  **/
20246 #ifdef ANSI
20247 PRIVATE Void rgSCHCmnHdlDlInactUes
20248 (
20249 RgSchCellCb  *cell
20250 )
20251 #else
20252 PRIVATE Void rgSCHCmnHdlDlInactUes(cell)
20253 RgSchCellCb  *cell;
20254 #endif
20255 {
20256    RgSchCmnCell *cellSch  = RG_SCH_CMN_GET_CELL(cell);
20257    CmLListCp    dlInactvLst;
20258    TRC2(rgSCHCmnHdlDlInactUes);
20259    /* Get a List of Inactv UEs for DL */
20260    cmLListInit(&dlInactvLst);
20261
20262    /* Trigger Spfc Schedulers with Inactive UEs */
20263    rgSCHMeasGapANRepGetDlInactvUe (cell, &dlInactvLst);
20264
20265    cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
20266    RETVOID;
20267 }
20268
20269 /* RACHO: Rach handover functions start here */
20270 /***********************************************************
20271  *
20272  *     Func : rgSCHCmnUeIdleExdThrsld
20273  *
20274  *     Desc : RETURN ROK if UE has been idle more
20275  *            than threshold.
20276  *
20277  *     Ret  :
20278  *
20279  *     Notes:
20280  *
20281  *     File :
20282  *
20283  **********************************************************/
20284 #ifdef ANSI
20285 PRIVATE S16 rgSCHCmnUeIdleExdThrsld
20286 (
20287 RgSchCellCb     *cell,
20288 RgSchUeCb       *ue
20289 )
20290 #else
20291 PRIVATE S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
20292 RgSchCellCb     *cell;
20293 RgSchUeCb       *ue;
20294 #endif
20295 {
20296    /* Time difference in subframes */
20297    U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
20298
20299    TRC2(rgSCHCmnUeIdleExdThrsld);
20300
20301    if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
20302    {
20303       RETVALUE(ROK);
20304    }
20305    else
20306    {
20307       RETVALUE(RFAILED);
20308    }
20309 }
20310
20311 \f
20312 /**
20313  * @brief Scheduler processing for Ded Preambles on cell configuration.
20314  *
20315  * @details
20316  *
20317  *     Function : rgSCHCmnCfgRachDedPrm
20318  *
20319  *     This function does requisite initialisation
20320  *     for RACH Ded Preambles.
20321  *
20322  *
20323  *  @param[in]  RgSchCellCb   *cell
20324  *  @return  Void
20325  **/
20326 #ifdef ANSI
20327 PRIVATE Void rgSCHCmnCfgRachDedPrm
20328 (
20329 RgSchCellCb   *cell
20330 )
20331 #else
20332 PRIVATE Void rgSCHCmnCfgRachDedPrm(cell)
20333 RgSchCellCb   *cell;
20334 #endif
20335 {
20336    RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20337    U32          gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20338    U32          sfDiff;
20339    U8           cnt;
20340    TRC2(rgSCHCmnCfgRachDedPrm);
20341
20342    if (cell->macPreambleSet.pres == NOTPRSNT)
20343    {
20344       RETVOID;
20345    }
20346    cellSch->rachCfg.numDedPrm = cell->macPreambleSet.size;
20347    cellSch->rachCfg.dedPrmStart = cell->macPreambleSet.start;
20348    /* Initialize handover List */
20349    cmLListInit(&cellSch->rachCfg.hoUeLst);
20350    /* Initialize pdcch Order List */
20351    cmLListInit(&cellSch->rachCfg.pdcchOdrLst);
20352
20353    /* Intialize the rapId to UE mapping structure */
20354    for (cnt = 0; cnt<cellSch->rachCfg.numDedPrm; cnt++)
20355    {
20356       cellSch->rachCfg.rapIdMap[cnt].rapId = cellSch->rachCfg.dedPrmStart + \
20357                                              cnt;
20358       cmLListInit(&cellSch->rachCfg.rapIdMap[cnt].assgndUes);
20359    }
20360    /* Perform Prach Mask Idx, remDedPrm, applFrm initializations */
20361    /* Set remDedPrm as numDedPrm */
20362    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20363    /* Initialize applFrm */
20364    cellSch->rachCfg.prachMskIndx = 0;
20365    if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_EVEN)
20366    {
20367       cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + \
20368             (cell->crntTime.sfn % 2)) % RGSCH_MAX_SFN;
20369    }
20370 #ifdef LTE_TDD
20371    else if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ODD)
20372    {
20373       if((cell->crntTime.sfn%2) == 0)
20374       {
20375          cellSch->rachCfg.applFrm.sfn = (cell->crntTime.sfn + 1)\
20376                                         % RGSCH_MAX_SFN;
20377       }
20378    }
20379 #endif
20380    else /* ANY sfn */
20381    {
20382       cellSch->rachCfg.applFrm.sfn = cell->crntTime.sfn;
20383    }
20384    /* Initialize cellSch->rachCfg.applFrm as >= crntTime.
20385     * This is because of RGSCH_CALC_SF_DIFF logic */
20386    if (cellSch->rachCfg.applFrm.sfn == cell->crntTime.sfn)
20387    {
20388       while (cellSch->rachCfg.prachMskIndx < cell->rachCfg.raOccasion.size)
20389       {
20390          if (cell->crntTime.slot <\
20391                cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx])
20392          {
20393             break;
20394          }
20395          cellSch->rachCfg.prachMskIndx++;
20396       }
20397       if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size)
20398       {
20399          if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20400          {
20401             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) %\
20402                                            RGSCH_MAX_SFN;
20403          }
20404          else
20405          {
20406             cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) %\
20407                                            RGSCH_MAX_SFN;
20408          }
20409          cellSch->rachCfg.prachMskIndx = 0;
20410       }
20411       cellSch->rachCfg.applFrm.slot = \
20412                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20413    }
20414    else
20415    {
20416       cellSch->rachCfg.applFrm.slot = \
20417                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20418    }
20419
20420    /* Note first param to this macro should always be the latest in time */
20421    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20422    while (sfDiff <= gap)
20423    {
20424       rgSCHCmnUpdNxtPrchMskIdx(cell);
20425       sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
20426    }
20427
20428    RETVOID;
20429 }
20430
20431 /**
20432  * @brief Updates the PRACH MASK INDEX.
20433  *
20434  * @details
20435  *
20436  *     Function: rgSCHCmnUpdNxtPrchMskIdx
20437  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20438  *     CFG is always >= "n"+"DELTA", where "n" is the crntTime
20439  *     of the cell. If not, applFrm is updated to the next avl
20440  *     PRACH oppurtunity as per the PRACH Cfg Index configuration.
20441  *
20442  *
20443  *     Invoked by: Common Scheduler
20444  *
20445  *  @param[in]  RgSchCellCb *cell
20446  *  @return  Void
20447  **/
20448 #ifdef ANSI
20449 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx
20450 (
20451 RgSchCellCb  *cell
20452 )
20453 #else
20454 PRIVATE Void rgSCHCmnUpdNxtPrchMskIdx(cell)
20455 RgSchCellCb  *cell;
20456 #endif
20457 {
20458    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20459    TRC2(rgSCHCmnUpdNxtPrchMskIdx);
20460
20461    /* Determine the next prach mask Index */
20462    if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
20463    {
20464       /* PRACH within applFrm.sfn are done, go to next AVL sfn */
20465       cellSch->rachCfg.prachMskIndx = 0;
20466       if (cell->rachCfg.raOccasion.sfnEnum == RGR_SFN_ANY)
20467       {
20468          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+1) % \
20469                                         RGSCH_MAX_SFN;
20470       }
20471       else/* RGR_SFN_EVEN or RGR_SFN_ODD */
20472       {
20473          cellSch->rachCfg.applFrm.sfn = (cellSch->rachCfg.applFrm.sfn+2) % \
20474                                         RGSCH_MAX_SFN;
20475       }
20476       cellSch->rachCfg.applFrm.slot = cell->rachCfg.raOccasion.\
20477                                           subFrameNum[0];
20478    }
20479    else /* applFrm.sfn is still valid */
20480    {
20481       cellSch->rachCfg.prachMskIndx += 1;
20482       if ( cellSch->rachCfg.prachMskIndx < RGR_MAX_SUBFRAME_NUM )
20483       {
20484          cellSch->rachCfg.applFrm.slot = \
20485                                           cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
20486       }
20487    }
20488    RETVOID;
20489 }
20490
20491 /**
20492  * @brief Updates the Ded preamble RACH parameters
20493  *        every TTI.
20494  *
20495  * @details
20496  *
20497  *     Function: rgSCHCmnUpdRachParam
20498  *     Purpose:  Ensures the "applFrm" field of Cmn Sched RACH
20499  *     CFG is always >= "n"+"6"+"DELTA", where "n" is the crntTime
20500  *     of the cell. If not, applFrm is updated to the next avl
20501  *     PRACH oppurtunity as per the PRACH Cfg Index configuration,
20502  *     accordingly the "remDedPrm" is reset to "numDedPrm" and
20503  *     "prachMskIdx" field is updated as per "applFrm".
20504  *
20505  *
20506  *     Invoked by: Common Scheduler
20507  *
20508  *  @param[in]  RgSchCellCb *cell
20509  *  @return  Void
20510  **/
20511 #ifdef ANSI
20512 PRIVATE Void rgSCHCmnUpdRachParam
20513 (
20514 RgSchCellCb  *cell
20515 )
20516 #else
20517 PRIVATE Void rgSCHCmnUpdRachParam(cell)
20518 RgSchCellCb  *cell;
20519 #endif
20520 {
20521
20522    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20523    U32             gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
20524    U32             sfDiff;
20525    TRC2(rgSCHCmnUpdRachParam);
20526
20527    if (cell->macPreambleSet.pres == NOTPRSNT)
20528    {
20529       RETVOID;
20530    }
20531    sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, \
20532          cell->crntTime);
20533    if (sfDiff > gap)
20534    {
20535       /* applFrm is still a valid next Prach Oppurtunity */
20536       RETVOID;
20537    }
20538    rgSCHCmnUpdNxtPrchMskIdx(cell);
20539    /* Reset remDedPrm as numDedPrm */
20540    cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
20541
20542    RETVOID;
20543 }
20544
20545 /**
20546  * @brief Dedicated Preamble allocation function.
20547  *
20548  * @details
20549  *
20550  *     Function: rgSCHCmnAllocPOParam
20551  *     Purpose:  Allocate pdcch, rapId and PrachMskIdx.
20552  *     Set mapping of UE with the allocated rapId.
20553  *
20554  *     Invoked by: Common Scheduler
20555  *
20556  *  @param[in]   RgSchCellCb *cell
20557  *  @param[in]   RgSchDlSf   *dlSf
20558  *  @param[in]   RgSchUeCb   *ue
20559  *  @param[out]  RgSchPdcch  **pdcch
20560  *  @param[out]  U8          *rapId
20561  *  @param[out]  U8          *prachMskIdx
20562  *  @return  Void
20563  **/
20564 #ifdef ANSI
20565 PRIVATE S16 rgSCHCmnAllocPOParam
20566 (
20567 RgSchCellCb  *cell,
20568 RgSchDlSf    *dlSf,
20569 RgSchUeCb    *ue,
20570 RgSchPdcch   **pdcch,
20571 U8           *rapId,
20572 U8           *prachMskIdx
20573 )
20574 #else
20575 PRIVATE S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
20576 RgSchCellCb  *cell;
20577 RgSchDlSf    *dlSf;
20578 RgSchUeCb    *ue;
20579 RgSchPdcch   **pdcch;
20580 U8           *rapId;
20581 U8           *prachMskIdx;
20582 #endif
20583 {
20584
20585    RgSchCmnCell    *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20586    RgSchCmnDlUe    *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20587
20588    TRC2(rgSCHCmnAllocPOParam);
20589
20590    if (cell->macPreambleSet.pres == PRSNT_NODEF)
20591    {
20592       if (cellSch->rachCfg.remDedPrm == 0)
20593       {
20594          RETVALUE(RFAILED);
20595       }
20596       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20597       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20598       {
20599          RETVALUE(RFAILED);
20600       }
20601       /* The stored prachMskIdx is the index of PRACH Oppurtunities in
20602        * raOccasions.subframes[].
20603        * Converting the same to the actual PRACHMskIdx to be transmitted. */
20604       *prachMskIdx = cellSch->rachCfg.prachMskIndx + 1;
20605       /* Distribution starts from dedPrmStart till dedPrmStart + numDedPrm */
20606       *rapId =  cellSch->rachCfg.dedPrmStart +
20607          cellSch->rachCfg.numDedPrm - cellSch->rachCfg.remDedPrm;
20608       cellSch->rachCfg.remDedPrm--;
20609       /* Map UE with the allocated RapId */
20610       ueDl->rachInfo.asgnOppr = cellSch->rachCfg.applFrm;
20611       RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, cellSch->rachCfg.rapIdMap, (*rapId - cellSch->rachCfg.dedPrmStart));
20612       cmLListAdd2Tail(&cellSch->rachCfg.rapIdMap[*rapId - cellSch->rachCfg.dedPrmStart].assgndUes, 
20613              &ueDl->rachInfo.rapIdLnk);
20614       ueDl->rachInfo.rapIdLnk.node = (PTR)ue;
20615       ueDl->rachInfo.poRapId = *rapId;
20616    }
20617    else /* if dedicated preambles not configured */
20618    {
20619       /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
20620       if ((*pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE)) == NULLP)
20621       {
20622          RETVALUE(RFAILED);
20623       }
20624       *prachMskIdx = 0;
20625       *rapId       = 0;
20626    }
20627
20628    RETVALUE(ROK);
20629 }
20630
20631 /**
20632  * @brief Dowlink Scheduling Handler.
20633  *
20634  * @details
20635  *
20636  *     Function: rgSCHCmnGenPdcchOrder
20637  *     Purpose:  For each UE in PO Q, grab a PDCCH,
20638  *     get an available ded RapId and fill PDCCH
20639  *     with PO information.
20640  *
20641  *     Invoked by: Common Scheduler
20642  *
20643  *  @param[in]  RgSchCellCb *cell
20644  *  @param[in]  RgSchDlSf   *dlSf
20645  *  @return  Void
20646  **/
20647 #ifdef ANSI
20648 PRIVATE Void rgSCHCmnGenPdcchOrder
20649 (
20650 RgSchCellCb  *cell,
20651 RgSchDlSf    *dlSf
20652 )
20653 #else
20654 PRIVATE Void rgSCHCmnGenPdcchOrder(cell, dlSf)
20655 RgSchCellCb  *cell;
20656 RgSchDlSf    *dlSf;
20657 #endif
20658 {
20659    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
20660    CmLList           *node = cellSch->rachCfg.pdcchOdrLst.first;
20661    RgSchUeCb         *ue;
20662    U8                rapId;
20663    U8                prachMskIdx;
20664    RgSchPdcch        *pdcch = NULLP;
20665
20666    TRC2(rgSCHCmnGenPdcchOrder);
20667
20668    while (node)
20669    {
20670       ue = (RgSchUeCb *)node->node;
20671       node = node->next;
20672       /* Skip sending for this subframe is Measuring or inActive in UL due
20673        * to MeasGap or inactie due to DRX
20674        */
20675       if  ((ue->measGapCb.isMeasuring == TRUE) ||
20676            (ue->ul.ulInactvMask & RG_MEASGAP_INACTIVE) ||
20677            (ue->isDrxEnabled &&
20678              ue->dl.dlInactvMask & RG_DRX_INACTIVE)
20679            )
20680       {
20681          continue;
20682       }
20683       if (rgSCHCmnAllocPOParam(cell, dlSf, ue, &pdcch, &rapId,\
20684                &prachMskIdx) != ROK)
20685       {
20686          /* No More rapIds left for the valid next avl Oppurtunity.
20687           * Unsatisfied UEs here would be given a chance, when the
20688           * prach Mask Index changes as per rachUpd every TTI */
20689
20690          /* PDDCH can also be ordered with rapId=0, prachMskIdx=0
20691           * so that UE triggers a RACH procedure with non-dedicated preamble.
20692           * But the implementation here does not do this. Instead, the "break"
20693           * here implies, that PDCCH Odr always given with valid rapId!=0,
20694           * prachMskIdx!=0 if dedicated preambles are configured.
20695           * If not configured, then trigger a PO with rapId=0,prchMskIdx=0*/
20696          break;
20697       }
20698       /* Fill pdcch with pdcch odr information */
20699       rgSCHCmnFillPdcchOdr2Sf(cell, ue, pdcch, rapId, prachMskIdx);
20700       /* Remove this UE from the PDCCH ORDER QUEUE */
20701       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20702       /* Reset UE's power state */
20703       rgSCHPwrUeReset(cell, ue);
20704    }
20705    RETVOID;
20706 }
20707
20708 \f
20709 /**
20710  * @brief This function add UE to PdcchOdr Q if not already present.
20711  *
20712  * @details
20713  *
20714  *     Function: rgSCHCmnDlAdd2PdcchOdrQ
20715  *     Purpose:
20716  *
20717  *     Invoked by: CMN Scheduler
20718  *
20719  *  @param[in]  RgSchCellCb*  cell
20720  *  @param[in]  RgSchUeCb*    ue
20721  *  @return  Void
20722  *
20723  **/
20724 #ifdef ANSI
20725 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ
20726 (
20727 RgSchCellCb                *cell,
20728 RgSchUeCb                  *ue
20729 )
20730 #else
20731 PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
20732 RgSchCellCb                *cell;
20733 RgSchUeCb                  *ue;
20734 #endif
20735 {
20736    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20737    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20738
20739    TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
20740
20741    if (ueDl->rachInfo.poLnk.node == NULLP)
20742    {
20743       cmLListAdd2Tail(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20744       ueDl->rachInfo.poLnk.node = (PTR)ue;
20745    }
20746    RETVOID;
20747 }
20748
20749 \f
20750 /**
20751  * @brief This function rmvs UE to PdcchOdr Q if not already present.
20752  *
20753  * @details
20754  *
20755  *     Function: rgSCHCmnDlRmvFrmPdcchOdrQ
20756  *     Purpose:
20757  *
20758  *     Invoked by: CMN Scheduler
20759  *
20760  *  @param[in]  RgSchCellCb*  cell
20761  *  @param[in]  RgSchUeCb*    ue
20762  *  @return  Void
20763  *
20764  **/
20765 #ifdef ANSI
20766 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ
20767 (
20768 RgSchCellCb                *cell,
20769 RgSchUeCb                  *ue
20770 )
20771 #else
20772 PRIVATE Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
20773 RgSchCellCb                *cell;
20774 RgSchUeCb                  *ue;
20775 #endif
20776 {
20777    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20778    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20779
20780    TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
20781
20782    cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
20783    ueDl->rachInfo.poLnk.node = NULLP;
20784    RETVOID;
20785 }
20786
20787 /**
20788  * @brief Fill pdcch with PDCCH order information.
20789  *
20790  * @details
20791  *
20792  *     Function: rgSCHCmnFillPdcchOdr2Sf
20793  *     Purpose:  Fill PDCCH with PDCCH order information,
20794  *
20795  *     Invoked by: Common Scheduler
20796  *
20797  *  @param[in]  RgSchUeCb   *ue
20798  *  @param[in]  RgSchPdcch  *pdcch
20799  *  @param[in]  U8          rapId
20800  *  @param[in]  U8          prachMskIdx
20801  *  @return  Void
20802  **/
20803 #ifdef ANSI
20804 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf
20805 (
20806 RgSchCellCb *cell,
20807 RgSchUeCb   *ue,
20808 RgSchPdcch  *pdcch,
20809 U8          rapId,
20810 U8          prachMskIdx
20811 )
20812 #else
20813 PRIVATE Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
20814 RgSchCellCb *cell;
20815 RgSchUeCb   *ue;
20816 RgSchPdcch  *pdcch;
20817 U8          rapId;
20818 U8          prachMskIdx;
20819 #endif
20820 {
20821    RgSchUeACqiCb  *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell); 
20822
20823    TRC2(rgSCHCmnFillPdcchOdr2Sf);
20824
20825    pdcch->rnti                                         = ue->ueId;
20826    pdcch->dci.dciFormat                                = TFU_DCI_FORMAT_1A;
20827    pdcch->dci.u.format1aInfo.isPdcchOrder = TRUE;
20828    pdcch->dci.u.format1aInfo.t.pdcchOrder.preambleIdx  = rapId;
20829    pdcch->dci.u.format1aInfo.t.pdcchOrder.prachMaskIdx = prachMskIdx;
20830
20831    /* Request for APer CQI immediately after PDCCH Order */
20832    /* CR ccpu00144525 */
20833 #ifdef TFU_UPGRADE
20834    if(ue->dl.ueDlCqiCfg.aprdCqiCfg.pres)
20835    {
20836       ue->dl.reqForCqi = RG_SCH_APCQI_SERVING_CC;
20837       acqiCb->aCqiTrigWt = 0;
20838    }
20839 #endif   
20840
20841    RETVOID;
20842 }
20843
20844 \f
20845 /**
20846  * @brief UE deletion for scheduler.
20847  *
20848  * @details
20849  *
20850  *     Function : rgSCHCmnDelRachInfo
20851  *
20852  *     This functions deletes all scheduler information
20853  *     pertaining to an UE.
20854  *
20855  *  @param[in]  RgSchCellCb  *cell
20856  *  @param[in]  RgSchUeCb    *ue
20857  *  @return  Void
20858  **/
20859 #ifdef ANSI
20860 PRIVATE Void rgSCHCmnDelRachInfo
20861 (
20862 RgSchCellCb  *cell,
20863 RgSchUeCb    *ue
20864 )
20865 #else
20866 PRIVATE Void rgSCHCmnDelRachInfo(cell, ue)
20867 RgSchCellCb  *cell;
20868 RgSchUeCb    *ue;
20869 #endif
20870 {
20871    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
20872    RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20873    U8            rapIdIdx;
20874
20875    TRC2(rgSCHCmnDelRachInfo);
20876
20877    if (ueDl->rachInfo.poLnk.node)
20878    {
20879       rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue);
20880    }
20881    if (ueDl->rachInfo.hoLnk.node)
20882    {
20883       cmLListDelFrm(&cellSch->rachCfg.hoUeLst, &ueDl->rachInfo.hoLnk);
20884       ueDl->rachInfo.hoLnk.node = NULLP;
20885    }
20886    if (ueDl->rachInfo.rapIdLnk.node)
20887    {
20888       rapIdIdx = ueDl->rachInfo.poRapId - cellSch->rachCfg.dedPrmStart;
20889       cmLListDelFrm(&cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes, 
20890           &ueDl->rachInfo.rapIdLnk);
20891       ueDl->rachInfo.rapIdLnk.node = NULLP;
20892    }
20893    RETVOID;
20894 }
20895
20896 /**
20897  * @brief This function retrieves the ue which has sent this raReq
20898  * and it allocates grant for UEs undergoing (for which RAR
20899  * is being generated) HandOver/PdcchOrder.
20900  *
20901  *
20902  * @details
20903  *
20904  *     Function: rgSCHCmnHdlHoPo
20905  *     Purpose:  This function  retrieves the ue which has sent this raReq
20906  *               and it allocates grant for UEs undergoing (for which RAR
20907  *               is being generated) HandOver/PdcchOrder.
20908  *
20909  *     Invoked by: Common Scheduler
20910  *
20911  *  @param[in]  RgSchCellCb           *cell
20912  *  @param[out] CmLListCp             *raRspLst
20913  *  @param[in]  RgSchRaReqInfo        *raReq
20914  *  @return  Void
20915  *
20916  **/
20917 #ifdef ANSI
20918 PRIVATE Void rgSCHCmnHdlHoPo
20919 (
20920 RgSchCellCb           *cell,
20921 CmLListCp             *raRspLst,
20922 RgSchRaReqInfo        *raReq
20923 )
20924 #else
20925 PRIVATE Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
20926 RgSchCellCb           *cell;
20927 CmLListCp             *raRspLst;
20928 RgSchRaReqInfo        *raReq;
20929 #endif
20930 {
20931    RgSchUeCb             *ue = raReq->ue;
20932    TRC2(rgSCHCmnHdlHoPo);
20933
20934    if ( ue->isDrxEnabled )
20935    {
20936       rgSCHDrxDedRa(cell,ue);
20937    }
20938    rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq);
20939    RETVOID;
20940 }
20941
20942 /**
20943  * @brief This function retrieves the UE which has sent this raReq
20944  * for handover case.
20945  *
20946  *
20947  * @details
20948  *
20949  *     Function: rgSCHCmnGetHoUe
20950  *     Purpose:  This function retrieves the UE which has sent this raReq
20951  *     for handover case.
20952  *
20953  *     Invoked by: Common Scheduler
20954  *
20955  *  @param[in]  RgSchCellCb           *cell
20956  *  @param[in]  RgSchRaReqInfo        *raReq
20957  *  @return  RgSchUeCb*
20958  *
20959  **/
20960 #ifdef ANSI
20961 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe
20962 (
20963 RgSchCellCb           *cell,
20964 U16                   rapId
20965 )
20966 #else
20967 PUBLIC RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
20968 RgSchCellCb           *cell;
20969 U16                   rapId
20970 #endif
20971 {
20972    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
20973    CmLList               *node;
20974    CmLListCp             *ueLst;
20975    RgSchUeCb             *ue;
20976    RgSchCmnDlUe          *ueDl;
20977    TRC2(rgSCHCmnGetHoUe);
20978
20979    ueLst = &cellSch->rachCfg.hoUeLst;
20980    node = ueLst->first;
20981    while (node)
20982    {
20983       ue = (RgSchUeCb *)node->node;
20984       node = node->next;
20985       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
20986       if (ueDl->rachInfo.hoRapId == rapId)
20987       {
20988          RETVALUE(ue);
20989       }
20990    }
20991    RETVALUE(NULLP);
20992 }
20993
20994 #ifdef ANSI
20995 PRIVATE Void rgSCHCmnDelDedPreamble
20996 (
20997 RgSchCellCb           *cell,
20998 U8                    preambleId
20999 )
21000 #else
21001 PRIVATE rgSCHCmnDelDedPreamble(cell, preambleId)
21002 RgSchCellCb           *cell;
21003 U8                    preambleId;
21004 #endif
21005 {
21006    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21007    CmLList               *node;
21008    CmLListCp             *ueLst;
21009    RgSchUeCb             *ue;
21010    RgSchCmnDlUe          *ueDl;
21011    TRC2(rgSCHCmnDelDedPreamble);
21012
21013    ueLst = &cellSch->rachCfg.hoUeLst;
21014    node = ueLst->first;
21015    while (node)
21016    {
21017       ue = (RgSchUeCb *)node->node;
21018       node = node->next;
21019       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21020       if (ueDl->rachInfo.hoRapId == preambleId)
21021       {
21022          cmLListDelFrm(ueLst, &ueDl->rachInfo.hoLnk);
21023          ueDl->rachInfo.hoLnk.node = (PTR)NULLP;
21024       }
21025    }
21026 }
21027
21028 /**
21029  * @brief This function retrieves the UE which has sent this raReq
21030  * for PDCCh Order case.
21031  *
21032  *
21033  * @details
21034  *
21035  *     Function: rgSCHCmnGetPoUe
21036  *     Purpose:  This function retrieves the UE which has sent this raReq
21037  *     for PDCCH Order case.
21038  *
21039  *     Invoked by: Common Scheduler
21040  *
21041  *  @param[in]  RgSchCellCb           *cell
21042  *  @param[in]  RgSchRaReqInfo        *raReq
21043  *  @return  RgSchUeCb*
21044  *
21045  **/
21046 #ifdef ANSI
21047 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe
21048 (
21049 RgSchCellCb           *cell,
21050 U16                   rapId,
21051 CmLteTimingInfo       timingInfo
21052 )
21053 #else
21054 PUBLIC RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
21055 RgSchCellCb           *cell;
21056 U16                   rapId;
21057 CmLteTimingInfo       timingInfo;
21058 #endif
21059 {
21060    RgSchCmnCell          *cellSch = (RgSchCmnCell *)(cell->sc.sch);
21061    CmLList               *node;
21062    CmLListCp             *ueLst;
21063    RgSchUeCb             *ue;
21064    RgSchCmnDlUe          *ueDl;
21065    U8                    rapIdIdx;
21066    TRC2(rgSCHCmnGetPoUe);
21067
21068    rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
21069    ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
21070    node = ueLst->first;
21071    while (node)
21072    {
21073       ue = (RgSchUeCb *)node->node;
21074       node = node->next;
21075       ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
21076       /* Remove UEs irrespective.
21077        * Old UE associations are removed.*/
21078       cmLListDelFrm(ueLst, &ueDl->rachInfo.rapIdLnk);
21079       ueDl->rachInfo.rapIdLnk.node = (PTR)NULLP;
21080       if (RGSCH_TIMEINFO_SAME(ueDl->rachInfo.asgnOppr, timingInfo))
21081       {
21082          RETVALUE(ue);
21083       }
21084    }
21085
21086    RETVALUE(NULLP);
21087 }
21088
21089
21090 /**
21091  * @brief This function returns the valid UL cqi for a given UE.
21092  *
21093  * @details
21094  *
21095  *     Function: rgSCHCmnUlGetCqi
21096  *     Purpose:  This function returns the "valid UL cqi" for a given UE
21097  *               based on UE category
21098  *
21099  *     Invoked by: Scheduler
21100  *     
21101  *  @param[in]  RgSchUeCb        *ue
21102  *  @param[in]  U8               ueCtgy
21103  *  @return     U8 
21104  **/
21105 #ifdef ANSI
21106 PUBLIC U8 rgSCHCmnUlGetCqi
21107 (
21108 RgSchCellCb      *cell,
21109 RgSchUeCb        *ue,
21110 CmLteUeCategory  ueCtgy
21111 )
21112 #else
21113 PUBLIC U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
21114 RgSchCellCb      *cell;
21115 RgSchUeCb        *ue;
21116 CmLteUeCategory  ueCtgy;
21117 #endif
21118 {
21119    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21120    U8            cqi;
21121
21122    TRC2(rgSCHCmnUlGetCqi);
21123    
21124    cqi = ueUl->maxUlCqi;
21125 #ifdef TFU_UPGRADE
21126    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21127         (ueUl->validUlCqi > ueUl->maxUlCqi)))
21128    {
21129       cqi = ueUl->validUlCqi;
21130    }
21131 #else   
21132    if (!((ueCtgy != CM_LTE_UE_CAT_5) && 
21133          (ueUl->crntUlCqi[0] > ueUl->maxUlCqi )))
21134    {
21135       cqi = ueUl->crntUlCqi[0];
21136    }
21137 #endif    
21138    RETVALUE(cqi);
21139 }/* End of rgSCHCmnUlGetCqi */
21140
21141 /***********************************************************
21142  *
21143  *     Func : rgSCHCmnUlRbAllocForPoHoUe
21144  *
21145  *     Desc : Do uplink RB allocation for a HO/PO UE.
21146  *
21147  *     Ret  :
21148  *
21149  *     Notes: Note that as of now, for retx, maxRb
21150  *            is not considered. Alternatives, such
21151  *            as dropping retx if it crosses maxRb
21152  *            could be considered.
21153  *
21154  *     File :
21155  *
21156  **********************************************************/
21157 #ifdef ANSI
21158 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe
21159 (
21160 RgSchCellCb           *cell,
21161 RgSchUlSf             *sf,
21162 RgSchUeCb             *ue,
21163 U8                    maxRb
21164 )
21165 #else
21166 PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
21167 RgSchCellCb           *cell;
21168 RgSchUlSf             *sf;
21169 RgSchUeCb             *ue;
21170 U8                    maxRb;
21171 #endif
21172 {
21173    RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21174    RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(ue,cell);
21175    U8           sbSize  = cellUl->sbSize;
21176    U32          maxBits = ue->ul.maxBytesPerUePerTti*8;
21177    U32          bits;
21178    RgSchUlAlloc *alloc;
21179    U32          nPrb;
21180    U8           iTbs;
21181    U32          eff;
21182    U32          numSb;
21183    U8           iMcs;
21184    U8           iMcsCrnt;
21185    U8           cqi;
21186    U8           modOdr;
21187    RgSchUlHole      *hole;
21188    RgSchUlHqProcCb  *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
21189    CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
21190
21191    TRC2(rgSCHCmnUlRbAllocForPoHoUe);
21192    if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
21193    {
21194       RETVALUE(RFAILED);
21195    }
21196    /*MS_WORKAROUND for HO ccpu00121116*/
21197    cqi   = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
21198    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend], cqi);
21199    iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21200    iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
21201    while(iMcs > RG_SCH_CMN_MAX_MSG3_IMCS)
21202    {
21203        cqi--;
21204        iTbs  = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
21205        iMcs  = rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg);
21206    }
21207    /* Filling the modorder in the grant structure*/
21208    RG_SCH_UL_MCS_TO_MODODR(iMcs,modOdr);
21209    if (!cell->isCpUlExtend)
21210    {
21211       eff   = rgSchCmnNorUlEff[0][iTbs];
21212    }
21213    else
21214    {
21215       eff   = rgSchCmnExtUlEff[0][iTbs];
21216    }
21217
21218    bits = ueUl->alloc.reqBytes * 8;
21219
21220 #if (ERRCLASS & ERRCLS_DEBUG)
21221    if (!bits)
21222    {
21223       RETVALUE(RFAILED);
21224    }
21225 #endif
21226
21227    if (bits < rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs))
21228    {
21229       numSb = 1;
21230       nPrb = numSb * sbSize;
21231    }
21232    else
21233    {
21234       if (bits > maxBits)
21235       {
21236          bits  = maxBits;
21237          nPrb  = bits * 1024 / eff / RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl);
21238          if (nPrb > maxRb)
21239          {
21240             nPrb = maxRb;
21241          }
21242          numSb = nPrb / sbSize;
21243       }
21244       else
21245       {
21246          /*ccpu00128775:MOD-Change to get upper threshold nPrb*/
21247          nPrb = RGSCH_CEIL((RGSCH_CEIL(bits * 1024, eff)),
21248                   RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl));
21249          if (nPrb > maxRb)
21250          {
21251             nPrb = maxRb;
21252          }
21253          numSb = RGSCH_DIV_ROUND(nPrb, sbSize);
21254       }
21255    }
21256    iMcsCrnt = iMcs;
21257
21258    alloc = rgSCHCmnUlSbAlloc(sf, (U8)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
21259                              hole);
21260    if (alloc == NULLP)
21261    {
21262       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
21263          "rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
21264       RETVALUE(RFAILED);
21265    }
21266    rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
21267    
21268    /* Filling the modorder in the grant structure start*/
21269    alloc->grnt.modOdr = (TfuModScheme) modOdr;
21270    alloc->grnt.iMcs = iMcs;
21271    alloc->grnt.iMcsCrnt = iMcsCrnt;
21272    alloc->grnt.hop = 0;
21273    /* Fix for ccpu00123915*/
21274    alloc->forMsg3 = TRUE;
21275    alloc->hqProc = proc;
21276    alloc->hqProc->ulSfIdx = cellUl->msg3SchdIdx;
21277    alloc->ue = ue;
21278    alloc->rnti = ue->ueId;
21279    /* updating initNumRbs in case of HO */
21280 #ifdef TFU_UPGRADE
21281    ue->initNumRbs = alloc->grnt.numRb;
21282 #endif
21283    ueUl->alloc.alloc = alloc;
21284    iTbs = rgSCHCmnUlGetITbsFrmIMcs(iMcs);
21285    RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgTbSzTbl[0], iTbs);
21286    alloc->grnt.datSz    = rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1] / 8;
21287    /* MS_WORKAROUND for HO ccpu00121124*/
21288    /*[Adi temp change] Need to fil modOdr */
21289    RG_SCH_UL_MCS_TO_MODODR(alloc->grnt.iMcsCrnt,alloc->grnt.modOdr);
21290    rgSCHUhmNewTx(proc, ueUl->hqEnt.maxHqRetx, alloc);
21291    /* No grant attr recorded now */
21292    RETVALUE(ROK);
21293 }
21294
21295 /**
21296  * @brief This function allocates grant for UEs undergoing (for which RAR
21297  * is being generated) HandOver/PdcchOrder.
21298  *
21299  *
21300  * @details
21301  *
21302  *     Function: rgSCHCmnAllocPoHoGrnt
21303  *     Purpose:  This function allocates grant for UEs undergoing (for which RAR
21304  *               is being generated) HandOver/PdcchOrder.
21305  *
21306  *     Invoked by: Common Scheduler
21307  *
21308  *  @param[in]  RgSchCellCb           *cell
21309  *  @param[out] CmLListCp             *raRspLst,
21310  *  @param[in]  RgSchUeCb             *ue
21311  *  @param[in]  RgSchRaReqInfo        *raReq
21312  *  @return  Void
21313  *
21314  **/
21315 #ifdef ANSI
21316 PRIVATE Void rgSCHCmnAllocPoHoGrnt
21317 (
21318 RgSchCellCb           *cell,
21319 CmLListCp             *raRspLst,
21320 RgSchUeCb             *ue,
21321 RgSchRaReqInfo        *raReq
21322 )
21323 #else
21324 PRIVATE Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
21325 RgSchCellCb           *cell;
21326 CmLListCp             *raRspLst;
21327 RgSchUeCb             *ue;
21328 RgSchRaReqInfo        *raReq;
21329 #endif
21330 {
21331    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21332    RgSchCmnUlUe    *ueUl   = RG_SCH_CMN_GET_UL_UE(ue,cell);
21333    RgSchUlGrnt     *grnt;
21334    RgSchUlSf       *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
21335
21336    TRC2(rgSCHCmnAllocPoHoGrnt);
21337
21338    /* Clearing previous allocs if any*/
21339    rgSCHCmnUlUeDelAllocs(cell, ue);
21340    /* Fix : syed allocs are limited */
21341    if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
21342    {
21343       RETVOID;
21344    }
21345    ueUl->alloc.reqBytes = RG_SCH_MIN_GRNT_HOPO;
21346    if (rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, RGSCH_MAX_UL_RB) != ROK)
21347    {
21348       RETVOID;
21349    }
21350
21351    /* Fill grant information */
21352    grnt = &ueUl->alloc.alloc->grnt;
21353
21354    /* KWork fix */
21355    if (grnt == NULLP)
21356    {
21357       RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx,  "Failed to get"
21358         "the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
21359       RETVOID;
21360    }
21361    ue->ul.rarGrnt.rapId = raReq->raReq.rapId;
21362    ue->ul.rarGrnt.hop = grnt->hop;
21363    ue->ul.rarGrnt.rbStart = grnt->rbStart;
21364    ue->ul.rarGrnt.numRb = grnt->numRb;
21365    ue->ul.rarGrnt.tpc = grnt->tpc;
21366    ue->ul.rarGrnt.iMcsCrnt = grnt->iMcsCrnt;
21367    ue->ul.rarGrnt.ta.pres = TRUE;
21368    ue->ul.rarGrnt.ta.val = raReq->raReq.ta;
21369    ue->ul.rarGrnt.datSz = grnt->datSz;
21370    if((sf->numACqiCount < RG_SCH_MAX_ACQI_PER_ULSF) && (RG_SCH_APCQI_NO != ue->dl.reqForCqi)) 
21371    {
21372 #ifdef LTE_ADV
21373       U8    idx = 0; 
21374       /* Send two bits cqireq field if more than one cells are configured else one*/
21375       for (idx = 1;idx < CM_LTE_MAX_CELLS;idx++)
21376       {
21377          if (ue->cellInfo[idx] != NULLP)
21378          {
21379             ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21380             break;
21381          }
21382       }
21383       if (idx == CM_LTE_MAX_CELLS)
21384 #endif
21385       {
21386          ue->ul.rarGrnt.cqiReqBit = ue->dl.reqForCqi;
21387       }
21388       ue->dl.reqForCqi = RG_SCH_APCQI_NO;
21389       sf->numACqiCount++;
21390    }
21391    else
21392    {
21393       ue->ul.rarGrnt.cqiReqBit = 0;
21394    }
21395    /* Attach Ho/Po allocation to RAR Rsp cont free Lst */
21396    cmLListAdd2Tail(raRspLst, &ue->ul.rarGrnt.raRspLnk);
21397    ue->ul.rarGrnt.raRspLnk.node = (PTR)ue;
21398
21399    RETVOID;
21400 }
21401
21402 /**
21403  * @brief This is a utility function to set the fields in
21404  * an UL harq proc which is identified for non-adaptive retx
21405  *
21406  * @details
21407  *
21408  *     Function: rgSCHCmnUlNonadapRetx 
21409  *     Purpose:  Sets the fields in UL Harq  proc for non-adaptive retx 
21410  *
21411  * @param[in]  RgSchCmnUlCell  *cellUl 
21412  * @param[out] RgSchUlAlloc    *alloc
21413  * @param[in]  U8              idx 
21414  * @return  Void
21415  *
21416  **/
21417 #ifdef UNUSED_FUNC
21418 #ifdef ANSI
21419 PRIVATE Void rgSCHCmnUlNonadapRetx
21420 (
21421 RgSchCmnUlCell  *cellUl,
21422 RgSchUlAlloc    *alloc,
21423 U8              idx
21424 )
21425 #else
21426 PRIVATE Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
21427 RgSchCmnUlCell  *cellUl;
21428 RgSchUlAlloc    *alloc;
21429 U8              idx;
21430 #endif
21431 {
21432    TRC2(rgSCHCmnUlNonadapRetx);
21433    rgSCHUhmRetx(alloc->hqProc, alloc);
21434
21435    /* Update alloc to retx */
21436    alloc->hqProc->isRetx = TRUE;
21437    alloc->hqProc->ulSfIdx = cellUl->reTxIdx[idx];
21438
21439    if (alloc->hqProc->rvIdx != 0)
21440    {
21441       alloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl[alloc->hqProc->rvIdx];
21442    }
21443    else
21444    {
21445       alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
21446    }
21447    alloc->grnt.isRtx = TRUE;
21448    alloc->pdcch = NULLP;
21449    RETVOID;
21450 }
21451 /**
21452  * @brief Check if 2 allocs overlap
21453  *
21454  * @details
21455  *
21456  *     Function : rgSCHCmnUlAllocsOvrLap
21457  *
21458  *      - Return TRUE if alloc1 and alloc2 overlap.
21459  *
21460  *  @param[in]  RgSchUlAlloc  *alloc1
21461  *  @param[in]  RgSchUlAlloc  *alloc2
21462  *  @return  Bool
21463  **/
21464 #ifdef ANSI
21465 PRIVATE Bool rgSCHCmnUlAllocsOvrLap
21466 (
21467 RgSchUlAlloc    *alloc1,
21468 RgSchUlAlloc    *alloc2
21469 )
21470 #else
21471 PRIVATE Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
21472 RgSchUlAlloc    *alloc1;
21473 RgSchUlAlloc    *alloc2;
21474 #endif
21475 {
21476
21477    TRC2(rgSCHCmnUlAllocsOvrLap);
21478
21479    if (((alloc1->sbStart >= alloc2->sbStart) &&
21480          (alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
21481         ((alloc2->sbStart >= alloc1->sbStart) &&
21482          (alloc2->sbStart <= alloc1->sbStart + alloc1->numSb-1)))
21483    {
21484       RETVALUE(TRUE);
21485    }
21486    RETVALUE(FALSE);
21487 }
21488 /**
21489  * @brief Copy allocation Info from src to dst.
21490  *
21491  * @details
21492  *
21493  *     Function : rgSCHCmnUlCpyAllocInfo
21494  *
21495  *      - Copy allocation Info from src to dst.
21496  *
21497  *  @param[in]  RgSchUlAlloc  *srcAlloc
21498  *  @param[in]  RgSchUlAlloc  *dstAlloc
21499  *  @return  Void
21500  **/
21501 #ifdef ANSI
21502 PRIVATE Void rgSCHCmnUlCpyAllocInfo
21503 (
21504 RgSchCellCb     *cell,
21505 RgSchUlAlloc    *srcAlloc,
21506 RgSchUlAlloc    *dstAlloc
21507 )
21508 #else
21509 PRIVATE Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
21510 RgSchCellCb     *cell;
21511 RgSchUlAlloc    *srcAlloc;
21512 RgSchUlAlloc    *dstAlloc;
21513 #endif
21514 {
21515    RgSchCmnUlUe *ueUl;
21516    TRC2(rgSCHCmnUlCpyAllocInfo);
21517
21518    dstAlloc->grnt = srcAlloc->grnt;
21519    dstAlloc->hqProc = srcAlloc->hqProc;
21520    /* Fix : syed During UE context release, hqProc->alloc
21521     * was pointing to srcAlloc instead of dstAlloc and
21522     * freeing from incorrect sf->allocDb was
21523     * corrupting the list. */
21524     /* In case of SPS Occasion Allocation is done in advance and 
21525        at a later time Hq Proc is linked. Hence HqProc
21526        pointer in alloc shall be NULL */
21527 #ifdef LTEMAC_SPS
21528    if (dstAlloc->hqProc)
21529 #endif
21530    {
21531       dstAlloc->hqProc->alloc = dstAlloc;
21532    }
21533    dstAlloc->ue = srcAlloc->ue;
21534    dstAlloc->rnti = srcAlloc->rnti;
21535    dstAlloc->forMsg3 = srcAlloc->forMsg3;
21536    dstAlloc->raCb  = srcAlloc->raCb;
21537    dstAlloc->pdcch = srcAlloc->pdcch;
21538    /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
21539    if (dstAlloc->ue)
21540    {
21541       ueUl = RG_SCH_CMN_GET_UL_UE(dstAlloc->ue,cell);
21542       ueUl->alloc.alloc = dstAlloc;
21543 #ifdef LTEMAC_SPS
21544       if (dstAlloc->ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
21545       {
21546          if((dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc != NULLP)
21547                && (dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc == srcAlloc))
21548          {
21549             dstAlloc->ue->ul.ulSpsInfo.ulSpsSchdInfo.crntAlloc = dstAlloc;
21550          }
21551       }
21552 #endif
21553    }
21554
21555    RETVOID;
21556 }
21557 /**
21558  * @brief Update TX and RETX subframe's allocation
21559  *        markings.
21560  *
21561  * @details
21562  *
21563  *     Function : rgSCHCmnUlInsAllocFrmNewSf2OldSf
21564  *
21565  *      - Release all preassigned allocations of newSf and merge
21566  *        them to oldSf.
21567  *      - If alloc of newSf collide with one or more allocs of oldSf
21568  *        - mark all such allocs of oldSf for Adaptive Retx.
21569  *      - Swap the alloc and hole DB references of oldSf and newSf.
21570  *
21571  *  @param[in]  RgSchCellCb   *cell
21572  *  @param[in]  RgSchUlSf     *newSf
21573  *  @param[in]  RgSchUlSf     *oldSf
21574  *  @param[in]  RgSchUlAlloc  *srcAlloc
21575  *  @return  Void
21576  **/
21577 #ifdef ANSI
21578 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
21579 (
21580 RgSchCellCb     *cell,
21581 RgSchUlSf       *newSf,
21582 RgSchUlSf       *oldSf,
21583 RgSchUlAlloc    *srcAlloc
21584 )
21585 #else
21586 PRIVATE Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
21587 RgSchCellCb     *cell;
21588 RgSchUlSf       *newSf;
21589 RgSchUlSf       *oldSf;
21590 RgSchUlAlloc    *srcAlloc;
21591 #endif
21592 {
21593    RgSchUlAlloc   *alloc, *dstAlloc, *nxtAlloc;
21594
21595    /* MS_WORKAROUND ccpu00120827 */
21596    RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
21597    U8 remAllocs;
21598    TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
21599
21600    if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21601    {
21602       do
21603       {
21604          nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);
21605          /* If there is an overlap between alloc and srcAlloc
21606           * then alloc is marked for Adaptive retx and it is released
21607           * from txSf */
21608          if (rgSCHCmnUlAllocsOvrLap(alloc, srcAlloc) == TRUE)
21609          {
21610             rgSCHCmnUlUpdAllocRetx(cell, alloc);
21611             rgSCHUtlUlAllocRls(oldSf, alloc);
21612          }
21613          /* No further allocs spanning the srcAlloc subbands */
21614          if (srcAlloc->sbStart + srcAlloc->numSb - 1  <= alloc->sbStart)
21615          {
21616             break;
21617          }
21618       } while ((alloc = nxtAlloc) != NULLP);
21619    }
21620
21621    /* After freeing all the colliding allocs, request for an allocation
21622     * specifying the start and numSb with in txSf. This function should
21623     * always return positively with a nonNULL dstAlloc */
21624     /* MS_WORKAROUND ccpu00120827 */
21625    remAllocs = schCmnCell->ul.maxAllocPerUlSf - *oldSf->allocCountRef;
21626    if (!remAllocs)
21627    {
21628       /* Fix : If oldSf already has max Allocs then release the
21629        * old RETX alloc to make space for new alloc of newSf.
21630        * newSf allocs(i.e new Msg3s) are given higher priority
21631        * over retx allocs. */      
21632       if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
21633       {
21634          do
21635          {
21636             nxtAlloc = rgSCHUtlUlAllocNxt(oldSf, alloc);           
21637             if (!alloc->mrgdNewTxAlloc)
21638             {
21639                /* If alloc is for RETX */                   
21640                /* TODO: Incase of this ad also in case of choosing
21641                 * and alloc for ADAP RETX, we need to send ACK for
21642                 * the corresponding alloc in PHICH */               
21643 #ifndef EMTC_ENABLE
21644                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc);
21645 #else
21646                rgSCHCmnUlFreeAllocation(cell, oldSf, alloc,FALSE);
21647 #endif
21648                break;
21649             }               
21650          }while((alloc = nxtAlloc) != NULLP);
21651       }
21652    }
21653    dstAlloc = rgSCHUtlUlGetSpfcAlloc(oldSf, srcAlloc->sbStart, srcAlloc->numSb);
21654 #ifdef ERRCLS_KW
21655    /* This should never happen */
21656    if (dstAlloc == NULLP)
21657    {
21658       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
21659          "rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
21660          srcAlloc->rnti);
21661       RETVOID;
21662    }
21663 #endif
21664    /* Copy the srcAlloc's state information in to dstAlloc */
21665    rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc);
21666    /* Set new Tx merged Alloc Flag to TRUE, indicating that this
21667     * alloc shall not be processed for non-adaptive retransmission */
21668    dstAlloc->mrgdNewTxAlloc = TRUE;
21669    RETVOID;
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  * @brief Swap Hole/Alloc DB context of newSf and oldSf.
21722  *
21723  * @details
21724  *
21725  *     Function : rgSCHCmnUlSwapSfAllocs
21726  *
21727  *      - Swap Hole/Alloc DB context of newSf and oldSf.
21728  *
21729  *  @param[in]  RgSchCellCb  *cell
21730  *  @param[in]  RgSchUlSf    *oldSf
21731  *  @param[in]  RgSchUlSf    *newSf
21732  *  @return  Void
21733  **/
21734 #ifdef ANSI
21735 PRIVATE Void rgSCHCmnUlSwapSfAllocs
21736 (
21737 RgSchCellCb  *cell,
21738 RgSchUlSf    *oldSf,
21739 RgSchUlSf    *newSf
21740 )
21741 #else
21742 PRIVATE Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
21743 RgSchCellCb  *cell;
21744 RgSchUlSf    *oldSf;
21745 RgSchUlSf    *newSf;
21746 #endif
21747 {
21748    RgSchUlAllocDb *tempAllocDb  = newSf->allocDb;
21749    RgSchUlHoleDb  *tempHoleDb   = newSf->holeDb;
21750    U8              tempAvailSbs = newSf->availSubbands;
21751
21752    TRC2(rgSCHCmnUlSwapSfAllocs);
21753    UNUSED(cell);
21754
21755    newSf->allocDb       = oldSf->allocDb;
21756    newSf->holeDb        = oldSf->holeDb;
21757    newSf->availSubbands = oldSf->availSubbands;
21758
21759    oldSf->allocDb = tempAllocDb;
21760    oldSf->holeDb  = tempHoleDb;
21761    oldSf->availSubbands = tempAvailSbs;
21762       
21763    /* Fix ccpu00120610*/
21764    newSf->allocCountRef = &newSf->allocDb->count;
21765    oldSf->allocCountRef = &oldSf->allocDb->count;
21766    RETVOID;
21767 }
21768 /**
21769  * @brief Perform non-adaptive RETX for non-colliding allocs.
21770  *
21771  * @details
21772  *
21773  *     Function : rgSCHCmnUlPrcNonAdptRetx
21774  *
21775  *      - Perform non-adaptive RETX for non-colliding allocs.
21776  *
21777  *  @param[in]  RgSchCellCb  *cell
21778  *  @param[in]  RgSchUlSf    *newSf
21779  *  @param[in]  U8           idx
21780  *  @return  Void
21781  **/
21782 #ifdef ANSI
21783 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx
21784 (
21785 RgSchCellCb  *cell,
21786 RgSchUlSf    *newSf,
21787 U8           idx
21788 )
21789 #else
21790 PRIVATE Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
21791 RgSchCellCb  *cell;
21792 RgSchUlSf    *newSf;
21793 U8           idx;
21794 #endif
21795 {
21796    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
21797    RgSchUlAlloc    *alloc, *nxtAlloc;
21798    TRC2(rgSCHCmnUlPrcNonAdptRetx);
21799
21800    /* perform non-adaptive retx allocation(adjustment) */
21801    if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
21802    {
21803       do
21804       {
21805          nxtAlloc = rgSCHUtlUlAllocNxt(newSf, alloc);
21806          /* A merged new TX alloc, reset the state and skip */
21807          if (alloc->mrgdNewTxAlloc)
21808          {
21809             alloc->mrgdNewTxAlloc = FALSE;
21810             continue;
21811          }
21812          
21813
21814          rgSCHCmnUlNonadapRetx(cellUl, alloc, idx);
21815
21816       } while((alloc = nxtAlloc) != NULLP);
21817    }
21818    RETVOID;
21819 }
21820
21821 /**
21822  * @brief Update TX and RETX subframe's allocation
21823  *        markings.
21824  *
21825  * @details
21826  *
21827  *     Function : rgSCHCmnUlPrfmSfMerge
21828  *
21829  *      - Release all preassigned allocations of newSf and merge
21830  *        them to oldSf.
21831  *      - If alloc of newSf collide with one or more allocs of oldSf
21832  *        - mark all such allocs of oldSf for Adaptive Retx.
21833  *      - Swap the alloc and hole DB references of oldSf and newSf.
21834  *      - The allocs which did not collide with pre-assigned msg3
21835  *        allocs are marked for non-adaptive RETX.
21836  *
21837  *  @param[in]  RgSchCellCb  *cell
21838  *  @param[in]  RgSchUlSf    *oldSf
21839  *  @param[in]  RgSchUlSf    *newSf
21840  *  @param[in]  U8           idx 
21841  *  @return  Void
21842  **/
21843 #ifdef ANSI
21844 PRIVATE Void rgSCHCmnUlPrfmSfMerge
21845 (
21846 RgSchCellCb  *cell,
21847 RgSchUlSf    *oldSf,
21848 RgSchUlSf    *newSf,
21849 U8           idx
21850 )
21851 #else
21852 PRIVATE Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
21853 RgSchCellCb  *cell;
21854 RgSchUlSf    *oldSf;
21855 RgSchUlSf    *newSf;
21856 U8           idx;
21857 #endif
21858 {
21859    TRC2(rgSCHCmnUlPrfmSfMerge);
21860    /* Preassigned resources for msg3 in newSf.
21861     * Hence do adaptive retx for all NACKED TXs */
21862    rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
21863    /* swap alloc and hole DBs of oldSf and newSf. */
21864    rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf);
21865    /* Here newSf has the resultant merged allocs context */
21866    /* Perform non-adaptive RETX for non-colliding allocs */
21867    rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx);
21868    
21869    RETVOID;
21870 }
21871 #endif
21872 /**
21873  * @brief Update TX and RETX subframe's allocation
21874  *        markings.
21875  *
21876  * @details
21877  *
21878  *     Function : rgSCHCmnUlRmvCmpltdAllocs
21879  *
21880  *      - Free all Transmission which are ACKED
21881  *        OR for which MAX retransmission have
21882  *        occurred.
21883  *
21884  *
21885  *  @param[in]  RgSchCellCb    *cell,
21886  *  @param[in]  RgSchUlSf      *sf
21887  *  @return  Void
21888  **/
21889 #ifdef ANSI
21890 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs
21891 (
21892 RgSchCellCb    *cell,
21893 RgSchUlSf      *sf
21894 )
21895 #else
21896 PRIVATE Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
21897 RgSchCellCb    *cell;
21898 RgSchUlSf      *sf;
21899 #endif
21900 {
21901    RgSchUlAlloc    *alloc, *nxtAlloc;
21902    TRC2(rgSCHCmnUlRmvCmpltdAllocs);
21903
21904    if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
21905    {
21906       RETVOID;
21907    }
21908    do
21909    {
21910       nxtAlloc = rgSCHUtlUlAllocNxt(sf, alloc);
21911 #ifdef UL_ADPT_DBG      
21912       printf("rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
21913 #endif
21914       alloc->hqProc->rcvdCrcInd = TRUE;
21915       if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
21916       {
21917
21918         /* SR_RACH_STATS : MSG 3 MAX RETX FAIL*/
21919          if ((alloc->forMsg3 == TRUE) && (alloc->hqProc->remTx == 0))
21920          {
21921             rgNumMsg3FailMaxRetx++;
21922 #ifdef TENB_STATS
21923             cell->tenbStats->sch.msg3Fail++;
21924 #endif
21925          }
21926
21927 #ifdef MAC_SCH_STATS
21928     if(alloc->ue != NULLP)
21929     {
21930        /* access from ulHarqProc*/
21931        RgSchUeCb       *ueCb  = alloc->ue;
21932        RgSchCmnUe      *cmnUe = (RgSchCmnUe*)ueCb->sch;
21933        RgSchCmnUlUe    *ulUe  = &(cmnUe->ul);
21934        U8              cqi    = ulUe->crntUlCqi[0];  
21935        U16             numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
21936
21937        hqRetxStats.ulCqiStat[(cqi - 1)].mcs = alloc->grnt.iMcs;
21938
21939        switch (numUlRetx)
21940        {
21941           case 1:
21942              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1++;
21943              break;
21944           case 2:
21945              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2++;
21946              break;
21947          case 3:
21948             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3++;
21949             break;
21950          case 4:
21951             hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4++;
21952             break;
21953       }
21954       hqRetxStats.ulCqiStat[(cqi - 1)].totalTx = \
21955              hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_1 + \
21956             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_2 * 2) + \
21957             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_3 * 3) + \
21958             (hqRetxStats.ulCqiStat[(cqi - 1)].numOfHQ_4 * 4);
21959    }
21960
21961 #endif /*MAC_SCH_STATS*/
21962          rgSCHCmnUlFreeAllocation(cell, sf, alloc);
21963       }
21964       /*ccpu00106104 MOD added check for AckNackRep */
21965       /*added check for acknack so that adaptive retx considers ue
21966        inactivity due to ack nack repetition*/
21967       else if((alloc->ue != NULLP) && (TRUE != alloc->forMsg3))
21968       {
21969         rgSCHCmnUlUpdAllocRetx(cell, alloc);
21970         rgSCHUtlUlAllocRls(sf, alloc);
21971       }
21972    } while ((alloc = nxtAlloc) != NULLP);
21973
21974    RETVOID;
21975 }
21976
21977 /**
21978  * @brief Update an uplink subframe.
21979  *
21980  * @details
21981  *
21982  *     Function : rgSCHCmnRlsUlSf
21983  *
21984  *     For each allocation
21985  *      - if no more tx needed
21986  *         - Release allocation
21987  *      - else
21988  *         - Perform retransmission
21989  *
21990  *  @param[in]  RgSchUlSf *sf
21991  *  @param[in]  U8        idx 
21992  *  @return  Void
21993  **/
21994 #ifdef ANSI
21995 PUBLIC Void rgSCHCmnRlsUlSf
21996 (
21997 RgSchCellCb    *cell,
21998 U8              idx
21999 )
22000 #else
22001 PUBLIC Void rgSCHCmnRlsUlSf(cell, idx)
22002 RgSchCellCb    *cell;
22003 U8              idx;
22004 #endif
22005 {
22006    TRC2(rgSCHCmnRlsUlSf);
22007
22008    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22009    
22010    if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO) 
22011    {
22012       RgSchUlSf   *oldSf  = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
22013
22014       /* Initialize the reTxLst of UL HqProcs for RETX subframe */
22015       if (rgSCHUtlUlAllocFirst(oldSf) == NULLP)
22016       {
22017          RETVOID;
22018       }
22019       /* Release all completed TX allocs from sf */
22020       rgSCHCmnUlRmvCmpltdAllocs(cell, oldSf);
22021
22022       oldSf->numACqiCount = 0;
22023    }
22024    RETVOID;
22025 }
22026
22027 /**
22028  * @brief Handle uplink allocation for retransmission.
22029  *
22030  * @details
22031  *
22032  *     Function : rgSCHCmnUlUpdAllocRetx
22033  *
22034  *     - Perform adaptive retransmission
22035  *
22036  *  @param[in]  RgSchUlSf *sf
22037  *  @param[in]  RgSchUlAlloc  *alloc
22038  *  @return  Void
22039  **/
22040 #ifdef ANSI
22041 PRIVATE Void rgSCHCmnUlUpdAllocRetx
22042 (
22043 RgSchCellCb    *cell,
22044 RgSchUlAlloc   *alloc
22045 )
22046 #else
22047 PRIVATE Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
22048 RgSchCellCb    *cell;
22049 RgSchUlAlloc   *alloc;
22050 #endif
22051 {
22052    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
22053
22054    TRC2(rgSCHCmnUlUpdAllocRetx);
22055
22056    alloc->hqProc->reTxAlloc.rnti    =  alloc->rnti;
22057    alloc->hqProc->reTxAlloc.numSb   =  alloc->numSb;
22058    alloc->hqProc->reTxAlloc.iMcs   =  alloc->grnt.iMcs;
22059 #ifdef RG_5GTF
22060    alloc->hqProc->reTxAlloc.dciFrmt =  alloc->grnt.dciFrmt;
22061    alloc->hqProc->reTxAlloc.numLyr   =  alloc->grnt.numLyr;
22062    alloc->hqProc->reTxAlloc.vrbgStart =  alloc->grnt.vrbgStart;
22063    alloc->hqProc->reTxAlloc.numVrbg   =  alloc->grnt.numVrbg;
22064    alloc->hqProc->reTxAlloc.modOdr   =  alloc->grnt.modOdr;
22065 #endif
22066    //iTbs = rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs);
22067    //iTbs = alloc->grnt.iMcs;
22068    //RGSCH_ARRAY_BOUND_CHECK( 0, rgTbSzTbl[0], iTbs);
22069    alloc->hqProc->reTxAlloc.tbSz = alloc->grnt.datSz;
22070       //rgTbSzTbl[0][iTbs][alloc->grnt.numRb-1]/8;
22071    alloc->hqProc->reTxAlloc.ue      = alloc->ue;
22072    alloc->hqProc->reTxAlloc.forMsg3 = alloc->forMsg3;
22073    alloc->hqProc->reTxAlloc.raCb = alloc->raCb;
22074
22075    /* Set as retransmission is pending */
22076    alloc->hqProc->isRetx = TRUE;
22077    alloc->hqProc->alloc = NULLP;
22078    alloc->hqProc->ulSfIdx = RGSCH_INVALID_INFO;
22079 #ifdef UL_ADPT_DBG  
22080    printf("Adding Harq Proc Id in the retx list  hqProcId %d \n",alloc->grnt.hqProcId); 
22081 #endif
22082    cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
22083    alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
22084    RETVOID;
22085 }
22086
22087 /**
22088  * @brief Attempts allocation for msg3s for which ADAP retransmissions
22089  *     are required.
22090  *
22091  * @details
22092  *
22093  *     Function : rgSCHCmnUlAdapRetxAlloc
22094  *
22095  *     Attempts allocation for msg3s for which ADAP retransmissions
22096  *     are required.
22097  *
22098  *  @param[in]  RgSchCellCb       *cell
22099  *  @param[in]  RgSchUlSf         *sf
22100  *  @param[in]  RgSchUlHqProcCb   *proc;
22101  *  @param[in]  RgSchUlHole       *hole;
22102  *  @return  U8
22103  **/
22104 #ifdef ANSI
22105 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc
22106 (
22107 RgSchCellCb       *cell,
22108 RgSchUlSf         *sf,
22109 RgSchUlHqProcCb   *proc,
22110 RgSchUlHole       *hole
22111 )
22112 #else
22113 PRIVATE Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
22114 RgSchCellCb       *cell;
22115 RgSchUlSf         *sf;
22116 RgSchUlHqProcCb   *proc;
22117 RgSchUlHole       *hole;
22118 #endif
22119 {
22120    U8              numSb = proc->reTxAlloc.numSb;
22121    U8              iMcs  = proc->reTxAlloc.iMcs;
22122    CmLteTimingInfo frm = cell->crntTime;
22123    RgSchCmnUlCell  *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22124    RgSchDlSf       *dlSf;
22125    RgSchPdcch      *pdcch;
22126    RgSchUlAlloc    *alloc;
22127    TRC2(rgSCHCmnUlAdapRetxAlloc);
22128
22129    /* Fetch PDCCH for msg3 */
22130    /* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
22131    /* Introduced timing delta for UL control */
22132    RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
22133    dlSf = rgSCHUtlSubFrmGet(cell, frm);
22134    pdcch = rgSCHCmnCmnPdcchAlloc(cell, dlSf);
22135    if (pdcch == NULLP)
22136    {
22137       RETVALUE(FALSE);
22138    }
22139
22140    /* Fetch UL Alloc for msg3 */
22141    if (numSb <= hole->num)
22142    {
22143       alloc                = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
22144       
22145       /* KWork fix */
22146          if(alloc == NULLP)
22147          {
22148             rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22149             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
22150                   "UL Alloc fail for msg3 retx for rnti: %d\n", 
22151                   proc->reTxAlloc.rnti);
22152             RETVALUE(FALSE);
22153          }
22154
22155       rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
22156       alloc->grnt.iMcs     = iMcs;
22157       alloc->grnt.datSz    = proc->reTxAlloc.tbSz;
22158 #ifdef RG_5GTF
22159 #else
22160       //RG_SCH_UL_MCS_TO_MODODR(iMcs, alloc->grnt.modOdr);
22161 #endif
22162       /* Fill UL Alloc for msg3 */
22163       /* RACHO : setting nDmrs to 0 and UlDelaybit to 0*/
22164       alloc->grnt.nDmrs    = 0;
22165       alloc->grnt.hop      = 0;
22166       alloc->grnt.delayBit = 0;
22167       alloc->grnt.isRtx    = TRUE;
22168       proc->ulSfIdx        = cellUl->schdIdx;
22169 #ifdef RG_5GTF
22170       proc->schdTime = cellUl->schdTime;
22171       alloc->grnt.hqProcId = proc->procId;
22172       alloc->grnt.dciFrmt = proc->reTxAlloc.dciFrmt;
22173       alloc->grnt.numLyr = proc->reTxAlloc.numLyr;
22174       alloc->grnt.vrbgStart = proc->reTxAlloc.vrbgStart;
22175       alloc->grnt.numVrbg = proc->reTxAlloc.numVrbg;
22176       alloc->grnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, alloc->grnt.vrbgStart, alloc->grnt.numVrbg);
22177       alloc->grnt.modOdr = proc->reTxAlloc.modOdr;
22178
22179       /* TODO : Hardcoding these as of now */
22180       alloc->grnt.hop = 0;
22181       alloc->grnt.SCID = 0;
22182       alloc->grnt.xPUSCHRange = MAX_5GTF_XPUSCH_RANGE;
22183       alloc->grnt.PMI = 0;
22184       alloc->grnt.uciOnxPUSCH = 0;
22185 #endif
22186       alloc->rnti          = proc->reTxAlloc.rnti;
22187       /* Fix : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22188       alloc->ue            = proc->reTxAlloc.ue;
22189       alloc->pdcch         = pdcch;
22190       alloc->forMsg3       = proc->reTxAlloc.forMsg3;
22191       alloc->raCb          = proc->reTxAlloc.raCb;
22192       alloc->hqProc        = proc;
22193       alloc->isAdaptive    = TRUE;
22194 #ifdef LTE_L2_MEAS
22195       sf->totPrb  += alloc->grnt.numRb;
22196 #endif
22197       /* FIX : syed HandIn Ue has forMsg3 and ue Set, but no RaCb */
22198       if (alloc->raCb)
22199       {
22200          alloc->raCb->msg3Grnt= alloc->grnt;
22201 #ifndef LTE_TDD
22202          /* To the crntTime, add the time at which UE will
22203           * actually send MSG3 */
22204          alloc->raCb->msg3AllocTime = cell->crntTime;
22205          RGSCH_INCR_SUB_FRAME(alloc->raCb->msg3AllocTime, RG_SCH_CMN_MIN_RETXMSG3_RECP_INTRVL);
22206 #else
22207          alloc->raCb->msg3AllocTime =  cellUl->schdTime;
22208 #endif
22209          rgSCHCmnUlAdapRetx(alloc, proc);
22210          /* Fill PDCCH with alloc info */
22211          pdcch->rnti                           = alloc->rnti;
22212          pdcch->dci.dciFormat                  = TFU_DCI_FORMAT_0;
22213          pdcch->dci.u.format0Info.hoppingEnbld = alloc->grnt.hop;
22214          pdcch->dci.u.format0Info.rbStart      = alloc->grnt.rbStart;
22215          pdcch->dci.u.format0Info.numRb        = alloc->grnt.numRb;
22216          pdcch->dci.u.format0Info.mcs          = alloc->grnt.iMcsCrnt;
22217          pdcch->dci.u.format0Info.ndi          = alloc->hqProc->ndi;
22218          pdcch->dci.u.format0Info.nDmrs        = alloc->grnt.nDmrs;
22219          pdcch->dci.u.format0Info.tpcCmd       = alloc->grnt.tpc;
22220
22221 #ifdef LTE_TDD
22222 #ifdef TFU_TDD
22223          /* ulIdx setting for cfg 0 shall be appropriately fixed thru ccpu00109015 */
22224          pdcch->dci.u.format0Info.ulIdx = RG_SCH_ULIDX_MSB;
22225          pdcch->dci.u.format0Info.dai = RG_SCH_MAX_DAI_IDX;
22226 #endif
22227 #endif
22228          pdcch->dciNumOfBits = cell->dciSize.size[TFU_DCI_FORMAT_0];
22229       }
22230       else
22231       {
22232          RgSchCmnUlUe *ueUl    = RG_SCH_CMN_GET_UL_UE(alloc->ue,cell);
22233 #ifdef TFU_UPGRADE
22234          alloc->ue->initNumRbs = (alloc->grnt.numVrbg * MAX_5GTF_VRBG_SIZE);
22235 #endif
22236 #ifdef LTE_L2_MEAS
22237          ue->ul.nPrb = alloc->grnt.numRb;
22238 #endif
22239          ueUl->alloc.alloc = alloc;
22240          /* FIx: Removed the call to rgSCHCmnUlAdapRetx */
22241          rgSCHCmnUlUeFillAllocInfo(cell, alloc->ue);
22242          /* Setting csireq as false for Adaptive Retx*/
22243          ueUl->alloc.alloc->pdcch->dci.u.format0Info.cqiReq = RG_SCH_APCQI_NO;
22244          pdcch->dciNumOfBits = alloc->ue->dciSize.cmnSize[TFU_DCI_FORMAT_0];
22245       }
22246       /* Reset as retransmission is done */
22247       proc->isRetx = FALSE;
22248    }
22249    else /* Intg fix */
22250    {
22251       rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
22252       RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
22253                "Num SB not suffiecient for adap retx for rnti: %d", 
22254                proc->reTxAlloc.rnti);
22255       RETVALUE(FALSE);
22256    }
22257    RETVALUE(TRUE);
22258 }
22259
22260 /* Fix: syed Adaptive Msg3 Retx crash. */
22261 /**
22262  * @brief Releases all Adaptive Retx HqProcs which failed for
22263  *        allocations in this scheduling occassion.
22264  *
22265  * @details
22266  *
22267  *     Function : rgSCHCmnUlSfRlsRetxProcs
22268  *
22269  *
22270  *  @param[in]  RgSchCellCb *cell
22271  *  @param[in]  RgSchUlSf   *sf
22272  *  @return  U8
22273  **/
22274 #ifdef UNUSED_FUNC
22275 #ifdef ANSI
22276 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs
22277 (
22278 RgSchCellCb *cell,
22279 RgSchUlSf   *sf
22280 )
22281 #else
22282 PRIVATE Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
22283 RgSchCellCb *cell;
22284 RgSchUlSf   *sf;
22285 #endif
22286 {
22287    CmLListCp         *cp;
22288    CmLList           *node;
22289    RgSchUlHqProcCb   *proc;
22290    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22291
22292    TRC2(rgSCHCmnUlSfRlsRetxProcs);
22293
22294    cp = &(cellUl->reTxLst);
22295    node = cp->first;
22296    while (node)
22297    {
22298       proc  = (RgSchUlHqProcCb *)node->node;
22299       node = node->next;
22300       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22301       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22302       proc->reTxLnk.node = (PTR)NULLP;
22303    }
22304    RETVOID;
22305 }
22306 #endif   
22307
22308 /**
22309  * @brief Attempts allocation for UEs for which retransmissions
22310  *     are required.
22311  *
22312  * @details
22313  *
22314  *     Function : rgSCHCmnUlSfReTxAllocs
22315  *
22316  *     Attempts allocation for UEs for which retransmissions
22317  *     are required.
22318  *
22319  *  @param[in]  RgSchCellCb *cell
22320  *  @param[in]  RgSchUlSf   *sf
22321  *  @return  U8
22322  **/
22323 #ifdef ANSI
22324 PRIVATE Void rgSCHCmnUlSfReTxAllocs
22325 (
22326 RgSchCellCb *cell,
22327 RgSchUlSf   *sf
22328 )
22329 #else
22330 PRIVATE Void rgSCHCmnUlSfReTxAllocs(cell, sf)
22331 RgSchCellCb *cell;
22332 RgSchUlSf   *sf;
22333 #endif
22334 {
22335    CmLListCp         *cp;
22336    CmLList           *node;
22337    RgSchUlHqProcCb   *proc;
22338    RgSchUlHole       *hole;
22339    RgSchUeCb         *ue;
22340    RgSchCmnCell      *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
22341    RgSchCmnUlCell    *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
22342    TRC2(rgSCHCmnUlSfReTxAllocs);
22343
22344    cp = &(cellUl->reTxLst);
22345    node = cp->first;
22346    while ((node))
22347    {
22348       proc  = (RgSchUlHqProcCb *)node->node;
22349       ue = proc->reTxAlloc.ue;
22350       node = node->next;
22351       /*ccpu00106104 MOD added check for AckNackRep */
22352       /*added check for acknack so that adaptive retx considers ue
22353        inactivity due to ack nack repetition*/
22354       if((ue != NULLP) &&
22355             ((ue->measGapCb.isMeasuring == TRUE)||
22356                (ue->ackNakRepCb.isAckNakRep == TRUE)))
22357       {
22358          continue;
22359       }
22360       /* Fix for ccpu00123917: Check if maximum allocs per UL sf have been exhausted */
22361       if (((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
22362             || (sf->allocDb->count == schCmnCell->ul.maxAllocPerUlSf))
22363       {
22364          /* No more UL BW then return */
22365          break;
22366       }
22367       /* perform adaptive retx for UE's */
22368       if (rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole) == FALSE)
22369       {
22370          continue;
22371       }
22372       /* ccpu00137834 : Deleting reTxLnk from the respective reTxLst */
22373       cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
22374       /* Fix: syed Adaptive Msg3 Retx crash. */
22375       proc->reTxLnk.node = (PTR)NULLP;
22376    }
22377    RETVOID;
22378 }
22379
22380 /**
22381  * @brief Handles RB allocation for downlink.
22382  *
22383  * @details
22384  *
22385  *     Function : rgSCHCmnDlRbAlloc
22386  *
22387  *     Invoking Module Processing:
22388  *     - This function is invoked for DL RB allocation
22389  *
22390  *     Processing Steps:
22391  *     - If cell is frequency selecive,
22392  *       - Call rgSCHDlfsAllocRb().
22393  *     - else,
22394  *       - Call rgSCHCmnNonDlfsRbAlloc().
22395  *
22396  *  @param[in]  RgSchCellCb        *cell
22397  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
22398  *  @return  Void
22399  **/
22400
22401 #ifdef ANSI
22402 PRIVATE Void rgSCHCmnDlRbAlloc
22403 (
22404 RgSchCellCb           *cell,
22405 RgSchCmnDlRbAllocInfo *allocInfo
22406 )
22407 #else
22408 PRIVATE Void rgSCHCmnDlRbAlloc(cell, allocInfo)
22409 RgSchCellCb           *cell;
22410 RgSchCmnDlRbAllocInfo *allocInfo;
22411 #endif
22412 {
22413    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
22414    TRC2(rgSCHCmnDlRbAlloc);
22415
22416    if (cellSch->dl.isDlFreqSel)
22417    {
22418       printf("5GTF_ERROR DLFS SCH Enabled\n");
22419       cellSch->apisDlfs->rgSCHDlfsAllocRb(cell, allocInfo);
22420    }
22421    else
22422    {
22423       rgSCHCmnNonDlfsRbAlloc(cell, allocInfo);
22424    }
22425    RETVOID;
22426 }
22427
22428 #ifdef LTEMAC_SPS
22429
22430 /**
22431  * @brief Determines number of RBGs and RBG subset sizes for the given DL
22432  * bandwidth and rbgSize
22433  *
22434  * @details
22435  *     Function : rgSCHCmnDlGetRbgInfo
22436  *
22437  *
22438  *     Processing Steps:
22439  *     - Fill-up rbgInfo data structure for given DL bandwidth and rbgSize
22440  *
22441  *   @param[in]  U8             dlTotalBw
22442  *   @param[in]  U8             dlSubsetBw
22443  *   @param[in]  U8             maxRaType1SubsetBw
22444  *   @param[in]  U8             rbgSize
22445  *   @param[out] RgSchBwRbgInfo *rbgInfo
22446  *  @return Void
22447  **/
22448 #ifdef ANSI
22449 PUBLIC Void rgSCHCmnDlGetRbgInfo
22450 (
22451 U8             dlTotalBw,
22452 U8             dlSubsetBw,
22453 U8             maxRaType1SubsetBw,
22454 U8             rbgSize,
22455 RgSchBwRbgInfo *rbgInfo
22456 )
22457 #else
22458 PUBLIC Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
22459       rbgSize, rbgInfo)
22460 U8             dlTotalBw;
22461 U8             dlSubsetBw;
22462 U8             maxRaType1SubsetBw;
22463 U8             rbgSize;
22464 RgSchBwRbgInfo *rbgInfo;
22465 #endif
22466 {
22467 #ifdef RGSCH_SPS_UNUSED
22468    U8    idx           = 0;
22469    U8    lastRbgIdx    = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
22470    U8    currRbgSize   = rbgSize;
22471    U8    subsetSizeIdx = 0;
22472    U8    subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
22473    U8    lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
22474    U8    numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
22475 #endif
22476
22477    /* Compute maximum number of SPS RBGs for the cell */
22478    rbgInfo->numRbgs =  ((dlSubsetBw + rbgSize - 1)/rbgSize);
22479
22480 #ifdef RGSCH_SPS_UNUSED
22481    /* Distribute RBGs across subsets except last RBG */
22482    for (;idx < numRaType1Rbgs - 1; ++idx)
22483    {
22484       subsetSize[subsetSizeIdx] += currRbgSize;
22485       subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22486    }
22487
22488    /* Computation for last RBG */
22489    if (idx == lastRbgIdx)
22490    {
22491       currRbgSize = lastRbgSize;
22492    }
22493    subsetSize[subsetSizeIdx] += currRbgSize;
22494    subsetSizeIdx = (subsetSizeIdx + 1) % rbgSize;
22495 #endif
22496
22497    /* Update the computed sizes */
22498 #ifdef RGSCH_SPS_UNUSED
22499    rbgInfo->lastRbgSize = currRbgSize;
22500 #endif
22501    rbgInfo->lastRbgSize = rbgSize - 
22502             (dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
22503 #ifdef RGSCH_SPS_UNUSED
22504    cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
22505 #endif
22506    rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
22507       dlTotalBw:(rbgInfo->numRbgs * rbgSize);
22508    rbgInfo->rbgSize = rbgSize;
22509 }
22510
22511 /**
22512  * @brief Handles RB allocation for Resource allocation type 0
22513  *
22514  * @details
22515  *
22516  *     Function : rgSCHCmnDlRaType0Alloc
22517  *
22518  *     Invoking Module Processing:
22519  *     - This function is invoked for DL RB allocation for resource allocation
22520  *     type 0
22521  *
22522  *     Processing Steps:
22523  *     - Determine the available positions in the rbgMask.
22524  *     - Allocate RBGs in the available positions.
22525  *     - Update RA Type 0, RA Type 1 and RA type 2 masks.
22526  *
22527  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22528  *  @param[in]   U8             rbsReq
22529  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22530  *  @param[out]  U8             *numAllocRbs
22531  *  @param[out]  RgSchDlSfAllocInfo *resAllocInfo
22532  *  @param[in]   Bool           isPartialAlloc
22533  *
22534  *  @return  Void
22535  **/
22536
22537 #ifdef ANSI
22538 PUBLIC U8 rgSCHCmnDlRaType0Alloc
22539 (
22540 RgSchDlSfAllocInfo *allocedInfo,
22541 U8                 rbsReq,
22542 RgSchBwRbgInfo     *rbgInfo,
22543 U8                 *numAllocRbs,
22544 RgSchDlSfAllocInfo *resAllocInfo,
22545 Bool               isPartialAlloc
22546 )
22547 #else
22548 PUBLIC U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
22549       numAllocRbs, resAllocInfo, isPartialAlloc)
22550 RgSchDlSfAllocInfo *allocedInfo;
22551 U8                 rbsReq;
22552 RgSchBwRbgInfo     *rbgInfo;
22553 U8                 *numAllocRbs;
22554 RgSchDlSfAllocInfo *resAllocInfo;
22555 Bool               isPartialAlloc;
22556 #endif
22557 {
22558    /* Note: This function atttempts allocation only full allocation */
22559    U32      remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
22560    U8       type2MaskIdx, cnt, rbIdx;
22561    U8       maskSize, rbg;
22562    U8       bestNumAvailRbs = 0;
22563    U8       usedRbs = 0;
22564    U8       numAllocRbgs = 0;
22565    U8       rbgSize = rbgInfo->rbgSize;
22566    U32      *rbgMask = &(resAllocInfo->raType0Mask);
22567 #ifdef RGSCH_SPS_UNUSED
22568    U8       rbgSubset;
22569    U32      ueRaType1Mask;
22570    U32      *raType1Mask = resAllocInfo->raType1Mask;
22571    U32      *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22572 #endif
22573    U32      *raType2Mask = resAllocInfo->raType2Mask;
22574
22575    U32      allocedMask = allocedInfo->raType0Mask;
22576
22577    maskSize = rbgInfo->numRbgs;
22578
22579    *numAllocRbs = 0;
22580    RG_SCH_CMN_DL_COUNT_ONES(allocedMask, maskSize, &usedRbs);
22581    if (maskSize == usedRbs)
22582    {
22583       /* All RBGs are allocated, including the last one */
22584       remNumRbs = 0;
22585    }
22586    else
22587    {
22588       remNumRbs = (maskSize - usedRbs - 1) * rbgSize; /* vamsee: removed minus 1 */
22589
22590       /* If last RBG is available, add last RBG size */
22591       if (!(allocedMask & (1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(maskSize - 1))))
22592       {
22593          remNumRbs += rbgInfo->lastRbgSize;
22594       }
22595    }
22596
22597    /* If complete allocation is needed, check if total requested RBs are available else
22598     * check the best available RBs */
22599    if (!isPartialAlloc)
22600    {
22601       if (remNumRbs >= rbsReq)
22602       {
22603          bestNumAvailRbs = rbsReq;
22604       }
22605    }
22606    else
22607    {
22608       bestNumAvailRbs = remNumRbs > rbsReq ? rbsReq : remNumRbs;
22609    }
22610
22611    /* Allocate for bestNumAvailRbs */
22612    if (bestNumAvailRbs)
22613    {
22614       for (rbg = 0; rbg < maskSize - 1; ++rbg)
22615       {
22616          rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22617          if (!(allocedMask & rbgPosInRbgMask))
22618          {
22619             /* Update RBG mask */
22620             *rbgMask |= rbgPosInRbgMask;
22621
22622             /* Compute RB index of the first RB of the RBG allocated */
22623             rbIdx = rbg * rbgSize;
22624
22625             for (cnt = 0; cnt < rbgSize; ++cnt)
22626             {
22627 #ifdef RGSCH_SPS_UNUSED
22628                ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22629 #endif
22630                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22631 #ifdef RGSCH_SPS_UNUSED
22632                /* Update RBG mask for RA type 1 */
22633                raType1Mask[rbgSubset] |= ueRaType1Mask;
22634                raType1UsedRbs[rbgSubset]++;
22635 #endif
22636                /* Update RA type 2 mask */
22637                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22638                rbIdx++;
22639             }
22640             *numAllocRbs += rbgSize;
22641             remNumRbs -= rbgSize;
22642             ++numAllocRbgs;
22643             if (*numAllocRbs >= bestNumAvailRbs)
22644             {
22645                break;
22646             }
22647          }
22648       }
22649       /* If last RBG available and allocation is not completed, allocate
22650        * last RBG */
22651       if (*numAllocRbs < bestNumAvailRbs)
22652       {
22653          rbgPosInRbgMask =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22654          *rbgMask |= rbgPosInRbgMask;
22655          *numAllocRbs += rbgInfo->lastRbgSize;
22656
22657          /* Compute RB index of the first RB of the last RBG */
22658          rbIdx = ((rbgInfo->numRbgs - 1 ) * rbgSize ); /* removed minus 1  vamsee */
22659
22660          for (cnt = 0; cnt < rbgInfo->lastRbgSize; ++cnt)
22661          {
22662 #ifdef RGSCH_SPS_UNUSED
22663             ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22664 #endif
22665             ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22666 #ifdef RGSCH_SPS_UNUSED
22667             /* Update RBG mask for RA type 1 */
22668             raType1Mask[rbgSubset] |=  ueRaType1Mask;
22669             raType1UsedRbs[rbgSubset]++;
22670 #endif
22671             /* Update RA type 2 mask */
22672             raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22673             rbIdx++;
22674          }
22675          remNumRbs -= rbgInfo->lastRbgSize;
22676          ++numAllocRbgs;
22677       }
22678       /* Note: this should complete allocation, not checking for the
22679        * same */
22680    }
22681
22682    RETVALUE(numAllocRbgs);
22683 }
22684
22685 #ifdef RGSCH_SPS_UNUSED
22686 /**
22687  * @brief Handles RB allocation for Resource allocation type 1
22688  *
22689  * @details
22690  *
22691  *     Function : rgSCHCmnDlRaType1Alloc
22692  *
22693  *     Invoking Module Processing:
22694  *     - This function is invoked for DL RB allocation for resource allocation
22695  *     type 1
22696  *
22697  *     Processing Steps:
22698  *     - Determine the available positions in the subsets.
22699  *     - Allocate RB in the available subset.
22700  *     - Update RA Type1, RA type 0 and RA type 2 masks.
22701  *
22702  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22703  *  @param[in]   U8                 rbsReq
22704  *  @param[in]   RgSchBwRbgInfo     *rbgInfo
22705  *  @param[in]   U8                 startRbgSubset
22706  *  @param[in]   U8                 *allocRbgSubset
22707  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22708  *  @param[in]   Bool               isPartialAlloc
22709  *
22710  *  @return  U8
22711  *  Number of allocated RBs
22712  **/
22713
22714 #ifdef ANSI
22715 PUBLIC U8 rgSCHCmnDlRaType1Alloc
22716 (
22717 RgSchDlSfAllocInfo *allocedInfo,
22718 U8                 rbsReq,
22719 RgSchBwRbgInfo     *rbgInfo,
22720 U8                 startRbgSubset,
22721 U8                 *allocRbgSubset,
22722 RgSchDlSfAllocInfo *resAllocInfo,
22723 Bool               isPartialAlloc
22724 )
22725 #else
22726 PUBLIC U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
22727       allocRbgSubset, resAllocInfo, isPartialAlloc)
22728 RgSchDlSfAllocInfo *allocedInfo;
22729 U8                 rbsReq;
22730 RgSchBwRbgInfo     *rbgInfo;
22731 U8                 startRbgSubset;
22732 U8                 *allocRbgSubset;
22733 RgSchDlSfAllocInfo *resAllocInfo;
22734 Bool               isPartialAlloc;
22735 #endif
22736 {
22737    /* Note: This function atttempts only full allocation */
22738    U8          *rbgSubsetSzArr;
22739    U8          type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
22740    U8          offset, rbg, maskSize, bestSubsetIdx;
22741    U8          startPos = 0;
22742    U8          bestNumAvailRbs = 0;
22743    U8          numAllocRbs = 0;
22744    U32         ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
22745    U32         remNumRbs, allocedMask;
22746    U8          usedRbs = 0;
22747    U8          rbgSize = rbgInfo->rbgSize;
22748    U8          rbgSubset = startRbgSubset;
22749    U32         *rbgMask = &resAllocInfo->raType0Mask;
22750    U32         *raType1Mask = resAllocInfo->raType1Mask;
22751    U32         *raType2Mask = resAllocInfo->raType2Mask;
22752    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22753    U32         *allocMask = allocedInfo->raType1Mask;
22754
22755    /* Initialize the subset size Array */
22756    rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
22757
22758    /* Perform allocation for RA type 1 */
22759    for (subsetIdx = 0;subsetIdx < rbgSize; ++subsetIdx)
22760    {
22761       allocedMask = allocMask[rbgSubset];
22762       maskSize = rbgSubsetSzArr[rbgSubset];
22763
22764       /* Determine number of available RBs in the subset */
22765       usedRbs = allocedInfo->raType1UsedRbs[subsetIdx];
22766       remNumRbs = maskSize - usedRbs;
22767
22768       if (remNumRbs >= rbsReq)
22769       {
22770          bestNumAvailRbs = rbsReq;
22771          bestSubsetIdx = rbgSubset;
22772          break;
22773       }
22774       else if (isPartialAlloc && (remNumRbs > bestNumAvailRbs))
22775       {
22776          bestNumAvailRbs = remNumRbs;
22777          bestSubsetIdx = rbgSubset;
22778       }
22779
22780       rbgSubset = (rbgSubset + 1) % rbgSize;
22781    } /* End of for (each rbgsubset) */
22782
22783    if (bestNumAvailRbs)
22784    {
22785       /* Initialize alloced mask and subsetSize depending on the RBG
22786        * subset of allocation */
22787       U8        startIdx = 0;
22788       maskSize = rbgSubsetSzArr[bestSubsetIdx];
22789       allocedMask = allocMask[bestSubsetIdx];
22790       RG_SCH_CMN_DL_GET_START_POS(allocedMask, maskSize,
22791             &startPos);
22792       for (; startIdx < rbgSize; ++startIdx, ++startPos)
22793       {
22794          for (rbInSubset = startPos; rbInSubset < maskSize;
22795                rbInSubset = rbInSubset + rbgSize)
22796          {
22797             rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
22798             if (!(allocedMask & rbPosInSubset))
22799             {
22800                raType1Mask[bestSubsetIdx] |= rbPosInSubset;
22801                raType1UsedRbs[bestSubsetIdx]++;
22802
22803                /* Compute RB index value for the RB being allocated */
22804                rbgInSubset = rbInSubset /rbgSize;
22805                offset = rbInSubset % rbgSize;
22806                rbg = (rbgInSubset * rbgSize) + bestSubsetIdx;
22807                rbIdx = (rbg * rbgSize) + offset;
22808
22809                /* Update RBG mask for RA type 0 allocation */
22810                ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22811                *rbgMask |= ueRaType0Mask;
22812
22813                /* Update RA type 2 mask */
22814                ueRaType2Mask = rgSCHCmnGetRaType2Mask(rbIdx, &type2MaskIdx);
22815                raType2Mask[type2MaskIdx] |= ueRaType2Mask;
22816
22817                /* Update the counters */
22818                numAllocRbs++;
22819                remNumRbs--;
22820                if (numAllocRbs == bestNumAvailRbs)
22821                {
22822                   break;
22823                }
22824             }
22825          } /* End of for (each position in the subset mask) */
22826          if (numAllocRbs == bestNumAvailRbs)
22827          {
22828             break;
22829          }
22830       } /* End of for startIdx = 0 to rbgSize */
22831
22832       *allocRbgSubset = bestSubsetIdx;
22833    } /* End of if (bestNumAvailRbs) */
22834
22835    RETVALUE(numAllocRbs);
22836 }
22837 #endif
22838 /**
22839  * @brief Handles RB allocation for Resource allocation type 2
22840  *
22841  * @details
22842  *
22843  *     Function : rgSCHCmnDlRaType2Alloc
22844  *
22845  *     Invoking Module Processing:
22846  *     - This function is invoked for DL RB allocation for resource allocation
22847  *     type 2
22848  *
22849  *     Processing Steps:
22850  *     - Determine the available positions in the mask
22851  *     - Allocate best fit cosecutive RBs.
22852  *     - Update RA Type2, RA type 1 and RA type 0 masks.
22853  *
22854  *  @param[in]   RgSchDlSfAllocInfo *allocedInfo
22855  *  @param[in]   U8             rbsReq
22856  *  @param[in]   RgSchBwRbgInfo *rbgInfo
22857  *  @param[out]  U8             *rbStart
22858  *  @param[out]  rgSchDlSfAllocInfo *resAllocInfo
22859  *  @param[in]   Bool           isPartialAlloc
22860  *
22861  *  @return  U8
22862  *  Number of allocated RBs
22863  **/
22864
22865 #ifdef ANSI
22866 PUBLIC U8 rgSCHCmnDlRaType2Alloc
22867 (
22868 RgSchDlSfAllocInfo *allocedInfo,
22869 U8                 rbsReq,
22870 RgSchBwRbgInfo     *rbgInfo,
22871 U8                 *rbStart,
22872 RgSchDlSfAllocInfo *resAllocInfo,
22873 Bool               isPartialAlloc
22874 )
22875 #else
22876 PUBLIC U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
22877       resAllocInfo, isPartialAlloc)
22878 RgSchDlSfAllocInfo *allocedInfo;
22879 U8                 rbsReq;
22880 RgSchBwRbgInfo     *rbgInfo;
22881 U8                 *rbStart;
22882 RgSchDlSfAllocInfo *resAllocInfo;
22883 Bool               isPartialAlloc;
22884 #endif
22885 {
22886    U8          numAllocRbs = 0;
22887    U8          rbIdx;
22888    U8          rbgSize = rbgInfo->rbgSize;
22889    U32         *rbgMask = &resAllocInfo->raType0Mask;
22890 #ifdef RGSCH_SPS_UNUSED
22891    U32         *raType1Mask = resAllocInfo->raType1Mask;
22892 #endif
22893    U32         *raType2Mask = resAllocInfo->raType2Mask;
22894 #ifdef RGSCH_SPS_UNUSED
22895    U32         *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
22896 #endif
22897    U32         *allocedMask = allocedInfo->raType2Mask;
22898
22899    /* Note: This function atttempts only full allocation */
22900    rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
22901          raType2Mask, rbsReq, rbStart, &numAllocRbs, isPartialAlloc);
22902    if (numAllocRbs)
22903    {
22904       /* Update the allocation in RA type 0 and RA type 1 masks */
22905       U8 rbCnt = numAllocRbs;
22906 #ifdef RGSCH_SPS_UNUSED
22907       U8 rbgSubset;
22908       U32 ueRaType1Mask;
22909 #endif
22910       U32 ueRaType0Mask;
22911       rbIdx = *rbStart;
22912
22913       while(rbCnt)
22914       {
22915          /* Update RBG mask for RA type 0 allocation */
22916          ueRaType0Mask = rgSCHCmnGetRaType0Mask(rbIdx, rbgSize);
22917          *rbgMask |= ueRaType0Mask;
22918
22919 #ifdef RGSCH_SPS_UNUSED
22920          /* Update RBG mask for RA type 1 */
22921          ueRaType1Mask = rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, &rbgSubset);
22922          raType1Mask[rbgSubset] |= ueRaType1Mask;
22923          raType1UsedRbs[rbgSubset]++;
22924 #endif
22925          /* Update the counters */
22926          --rbCnt;
22927          rbIdx++;
22928       }
22929    }
22930
22931    RETVALUE(numAllocRbs);
22932 }
22933
22934 /**
22935  * @brief Determines RA type 0 mask from given RB index.
22936  *
22937  * @details
22938  *
22939  *     Function : rgSCHCmnGetRaType0Mask
22940  *
22941  *
22942  *     Processing Steps:
22943  *     - Determine RA Type 0 mask for given rbIdex and rbg size.
22944  *
22945  *  @param[in]  U8          rbIdx
22946  *  @param[in]  U8          rbgSize
22947  *  @return  U32 RA type 0 mask
22948  **/
22949 #ifdef ANSI
22950 PRIVATE U32 rgSCHCmnGetRaType0Mask
22951 (
22952 U8                rbIdx,
22953 U8                rbgSize
22954 )
22955 #else
22956 PRIVATE U32 rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
22957 U8                rbIdx;
22958 U8                rbgSize;
22959 #endif
22960 {
22961    U8 rbg;
22962    U32 rbgPosInRbgMask = 0;
22963
22964    rbg = rbIdx/rbgSize;
22965    rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
22966
22967    RETVALUE(rbgPosInRbgMask);
22968 }
22969
22970 #ifdef RGSCH_SPS_UNUSED
22971 /**
22972  * @brief Determines RA type 1 mask from given RB index.
22973  *
22974  * @details
22975  *
22976  *     Function : rgSCHCmnGetRaType1Mask
22977  *
22978  *
22979  *     Processing Steps:
22980  *     - Determine RA Type 1 mask for given rbIdex and rbg size.
22981  *
22982  *  @param[in]  U8          rbIdx
22983  *  @param[in]  U8          rbgSize
22984  *  @param[out] U8          *type1Subset
22985  *  @return  U32 RA type 1 mask
22986  **/
22987 #ifdef ANSI
22988 PRIVATE U32 rgSCHCmnGetRaType1Mask
22989 (
22990 U8                rbIdx,
22991 U8                rbgSize,
22992 U8                *type1Subset
22993 )
22994 #else
22995 PRIVATE U32 rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
22996 U8                rbIdx;
22997 U8                rbgSize;
22998 U8                *type1Subset;
22999 #endif
23000 {
23001    U8 rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
23002    U32 rbPosInSubset;
23003
23004    rbg = rbIdx/rbgSize;
23005    rbgSubset = rbg % rbgSize;
23006    rbgInSubset = rbg/rbgSize;
23007    offset = rbIdx % rbgSize;
23008    rbInSubset = rbgInSubset * rbgSize + offset;
23009    rbPosInSubset =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbInSubset);
23010
23011    *type1Subset = rbgSubset;
23012    RETVALUE(rbPosInSubset);
23013 } 
23014 #endif /* RGSCH_SPS_UNUSED */
23015 /**
23016  * @brief Determines RA type 2 mask from given RB index.
23017  *
23018  * @details
23019  *
23020  *     Function : rgSCHCmnGetRaType2Mask
23021  *
23022  *
23023  *     Processing Steps:
23024  *     - Determine RA Type 2 mask for given rbIdx and rbg size.
23025  *
23026  *  @param[in]  U8          rbIdx
23027  *  @param[out] U8          *maskIdx
23028  *  @return  U32 RA type 2 mask
23029  **/
23030 #ifdef ANSI
23031 PRIVATE U32 rgSCHCmnGetRaType2Mask
23032 (
23033 U8                rbIdx,
23034 U8                *maskIdx
23035 )
23036 #else
23037 PRIVATE U32 rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
23038 U8                rbIdx;
23039 U8                *maskIdx;
23040 #endif
23041 {
23042    U32 rbPosInType2;
23043
23044    *maskIdx = rbIdx / 32;
23045    rbPosInType2 =  1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
23046
23047    RETVALUE(rbPosInType2);
23048 }
23049
23050 /**
23051  * @brief Performs resource allocation for a non-SPS UE in SPS bandwidth
23052  *
23053  * @details
23054  *
23055  *     Function : rgSCHCmnAllocUeInSpsBw
23056  *
23057  *
23058  *     Processing Steps:
23059  *       - Determine allocation for the UE.
23060  *       - Use resource allocation type 0, 1 and 2 for allocation
23061  *         within maximum SPS bandwidth.
23062  *
23063  *  @param[in]  RgSchDlSf       *dlSf
23064  *  @param[in]  RgSchCellCb     *cell
23065  *  @param[in]  RgSchUeCb       *ue
23066  *  @param[in]  RgSchDlRbAlloc  *rbAllocInfo
23067  *  @param[in]  Bool            isPartialAlloc
23068  *  @return  Bool
23069  *             ROK      success
23070  *             RFAILED  failed
23071  **/
23072 #ifdef ANSI
23073 PUBLIC Bool rgSCHCmnAllocUeInSpsBw
23074 (
23075 RgSchDlSf           *dlSf,
23076 RgSchCellCb         *cell,
23077 RgSchUeCb           *ue,
23078 RgSchDlRbAlloc      *rbAllocInfo,
23079 Bool                isPartialAlloc
23080 )
23081 #else
23082 PUBLIC Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
23083 RgSchDlSf           *dlSf;
23084 RgSchCellCb         *cell;
23085 RgSchUeCb           *ue;
23086 RgSchDlRbAlloc      *rbAllocInfo;
23087 Bool                isPartialAlloc;
23088 #endif
23089 {
23090    U8                  rbgSize = cell->rbgSize;
23091    U8                  numAllocRbs = 0;
23092    U8                  numAllocRbgs = 0;
23093    U8                  rbStart = 0;
23094    U8                  idx, noLyr, iTbs;
23095    RgSchCmnDlUe        *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
23096    RgSchDlSfAllocInfo  *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
23097    RgSchBwRbgInfo      *spsRbgInfo = &cell->spsBwRbgInfo;
23098
23099    /* SPS_FIX : Check if this Hq proc is scheduled */
23100    if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
23101          (0 == rbAllocInfo->tbInfo[1].schdlngForTb))
23102    {
23103       RETVALUE(TRUE);
23104    }
23105
23106    /* Check if the requirement can be accomodated in SPS BW */
23107    if (dlSf->spsAllocdBw == spsRbgInfo->numRbs)
23108    {
23109       /* SPS Bandwidth has been exhausted: no further allocations possible */
23110       RETVALUE(FALSE);
23111    }
23112    if (!isPartialAlloc)
23113    {
23114       if((dlSf->spsAllocdBw + rbAllocInfo->rbsReq) > spsRbgInfo->numRbs)
23115       {
23116          RETVALUE(TRUE);
23117       }
23118    }
23119
23120    /* Perform allocation for RA type 0 if rbsReq is multiple of RBG size (also
23121     * if RBG size = 1) */
23122    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23123    {
23124       rbAllocInfo->rbsReq += (rbgSize - rbAllocInfo->rbsReq % rbgSize);
23125       numAllocRbgs = rgSCHCmnDlRaType0Alloc(dlSfAlloc,
23126             rbAllocInfo->rbsReq, spsRbgInfo, &numAllocRbs,
23127             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23128    }
23129 #ifdef RGSCH_SPS_UNUSED
23130    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23131    {
23132       /* If no RBS could be allocated, attempt RA TYPE 1 */
23133
23134       numAllocRbs = rgSCHCmnDlRaType1Alloc(dlSfAlloc,
23135             rbAllocInfo->rbsReq, spsRbgInfo, (U8)dlSfAlloc->nxtRbgSubset,
23136             &rbAllocInfo->allocInfo.raType1.rbgSubset,
23137             &rbAllocInfo->resAllocInfo, isPartialAlloc);
23138
23139       if(numAllocRbs)
23140       {
23141          dlSfAlloc->nxtRbgSubset =
23142             (rbAllocInfo->allocInfo.raType1.rbgSubset + 1 ) % rbgSize;
23143       }
23144    }
23145 #endif
23146    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23147    {
23148       numAllocRbs = rgSCHCmnDlRaType2Alloc(dlSfAlloc,
23149             rbAllocInfo->rbsReq, spsRbgInfo,
23150             &rbStart, &rbAllocInfo->resAllocInfo, isPartialAlloc);
23151    }
23152    if (!numAllocRbs)
23153    {
23154       RETVALUE(TRUE);
23155    }
23156
23157    if (!(rbAllocInfo->pdcch =
23158             rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi,\
23159                rbAllocInfo->dciFormat, FALSE)))
23160    {
23161       /* Note: Returning TRUE since PDCCH might be available for another UE */
23162       RETVALUE(TRUE);
23163    }
23164
23165    /* Update Tb info for each scheduled TB */
23166    iTbs = rbAllocInfo->tbInfo[0].iTbs;
23167    noLyr = rbAllocInfo->tbInfo[0].noLyr;
23168    rbAllocInfo->tbInfo[0].bytesAlloc =
23169       rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;
23170
23171    if (rbAllocInfo->tbInfo[1].schdlngForTb)
23172    {
23173       iTbs = rbAllocInfo->tbInfo[1].iTbs;
23174       noLyr = rbAllocInfo->tbInfo[1].noLyr;
23175       rbAllocInfo->tbInfo[1].bytesAlloc =
23176          rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;;
23177    }
23178
23179    /* Update rbAllocInfo with the allocation information */
23180    if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE0)
23181    {
23182       rbAllocInfo->allocInfo.raType0.dlAllocBitMask =
23183          rbAllocInfo->resAllocInfo.raType0Mask;
23184       rbAllocInfo->allocInfo.raType0.numDlAlloc = numAllocRbgs;
23185    }
23186 #ifdef RGSCH_SPS_UNUSED
23187    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE1)
23188    {
23189       rbAllocInfo->allocInfo.raType1.dlAllocBitMask =
23190          rbAllocInfo->resAllocInfo.raType1Mask[rbAllocInfo->allocInfo.raType1.rbgSubset];
23191       rbAllocInfo->allocInfo.raType1.numDlAlloc = numAllocRbs;
23192       rbAllocInfo->allocInfo.raType1.shift = 0;
23193    }
23194 #endif
23195    else if (rbAllocInfo->raType == RG_SCH_CMN_RA_TYPE2)
23196    {
23197       rbAllocInfo->allocInfo.raType2.isLocal = TRUE;
23198       rbAllocInfo->allocInfo.raType2.rbStart = rbStart;
23199       rbAllocInfo->allocInfo.raType2.numRb = numAllocRbs;
23200    }
23201
23202    rbAllocInfo->rbsAlloc = numAllocRbs;
23203    rbAllocInfo->tbInfo[0].schdlngForTb = TRUE;
23204
23205    /* Update allocation masks for RA types 0, 1 and 2 in DL SF */
23206
23207    /* Update type 0 allocation mask */
23208    dlSfAlloc->raType0Mask |= rbAllocInfo->resAllocInfo.raType0Mask;
23209 #ifdef RGSCH_SPS_UNUSED
23210    /* Update type 1 allocation masks */
23211    for (idx = 0; idx < RG_SCH_NUM_RATYPE1_32BIT_MASK; ++idx)
23212    {
23213       dlSfAlloc->raType1Mask[idx] |= rbAllocInfo->resAllocInfo.raType1Mask[idx];
23214       dlSfAlloc->raType1UsedRbs[idx] +=
23215          rbAllocInfo->resAllocInfo.raType1UsedRbs[idx];
23216    }
23217 #endif
23218    /* Update type 2 allocation masks */
23219    for (idx = 0; idx < RG_SCH_NUM_RATYPE2_32BIT_MASK; ++idx)
23220    {
23221       dlSfAlloc->raType2Mask[idx] |= rbAllocInfo->resAllocInfo.raType2Mask[idx];
23222    }
23223
23224    dlSf->spsAllocdBw += numAllocRbs;
23225    RETVALUE(TRUE);
23226 }
23227
23228 /***********************************************************
23229  *
23230  *     Func : rgSCHCmnDlGetBestFitHole
23231  *
23232  *
23233  *     Desc : Converts the best fit hole into allocation and returns the
23234  *     allocation information.
23235  *
23236  *
23237  *     Ret  : Void
23238  *
23239  *
23240  *     Notes:
23241  *
23242  *     File :
23243  *
23244  **********************************************************/
23245 #ifdef ANSI
23246 PRIVATE Void rgSCHCmnDlGetBestFitHole
23247 (
23248 U32         *allocMask,
23249 U8          numMaskRbs,
23250 U32         *crntAllocMask,
23251 U8          rbsReq,
23252 U8          *allocStart,
23253 U8          *allocNumRbs,
23254 Bool        isPartialAlloc
23255 )
23256 #else
23257 PRIVATE  Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
23258         crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
23259 U32         *allocMask;
23260 U8          numMaskRbs;
23261 U32         *crntAllocMask;
23262 U8          rbsReq;
23263 U8          *allocStart;
23264 U8          *allocNumRbs;
23265 Bool        isPartialAlloc;
23266 #endif
23267 {
23268    U8 maskSz = (numMaskRbs + 31)/32;
23269    U8 maxMaskPos = (numMaskRbs % 32);
23270    U8 maskIdx, maskPos;
23271    U8 numAvailRbs = 0;
23272    U8 bestAvailNumRbs = 0;
23273    S8 bestStartPos = -1;
23274    S8 startPos = -1;
23275    U32 tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23276    U32 bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
23277
23278    *allocNumRbs = numAvailRbs;
23279    *allocStart = 0;
23280
23281    for (maskIdx = 0; maskIdx < maskSz; ++maskIdx)
23282    {
23283       maxMaskPos = 31;
23284       if (maskIdx == (maskSz - 1))
23285       {
23286          if (numMaskRbs % 32)
23287          {
23288             maxMaskPos = numMaskRbs % 32;
23289          }
23290       }
23291       for (maskPos = 0; maskPos < maxMaskPos; ++maskPos)
23292       {
23293          if (!(allocMask[maskIdx] & (1 << (31 - maskPos))))
23294          {
23295             tmpMask[maskIdx] |= (1 << (31 - maskPos));
23296             if (startPos == -1)
23297             {
23298                startPos = maskIdx * 32 + maskPos;
23299             }
23300             ++numAvailRbs;
23301             if (numAvailRbs == rbsReq)
23302             {
23303                *allocStart = (U8)startPos;
23304                *allocNumRbs = rbsReq;
23305                break;
23306             }
23307          }
23308          else
23309          {
23310             if (numAvailRbs > bestAvailNumRbs)
23311             {
23312                bestAvailNumRbs = numAvailRbs;
23313                bestStartPos = startPos;
23314                cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
23315             }
23316             numAvailRbs = 0;
23317             startPos = -1;
23318             cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
23319          }
23320       }
23321       if (*allocNumRbs == rbsReq)
23322       {
23323          break;
23324       }
23325    }
23326
23327    if (*allocNumRbs == rbsReq)
23328    {
23329       /* Convert the hole into allocation */
23330       cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
23331       RETVOID;
23332    }
23333    else
23334    {
23335       if (bestAvailNumRbs && isPartialAlloc)
23336       {
23337          /* Partial allocation could have been done */
23338          *allocStart = (U8)bestStartPos;
23339          *allocNumRbs = bestAvailNumRbs;
23340          /* Convert the hole into allocation */
23341          cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
23342       }
23343    }
23344
23345    RETVOID;
23346 }
23347 #endif /* LTEMAC_SPS */
23348
23349 /***************************************************************************
23350  *
23351  * NON-DLFS Allocation functions
23352  *
23353  * *************************************************************************/
23354 #ifndef LTE_TDD
23355 #ifdef DEBUGP
23356 /**
23357  * @brief Function to find out code rate
23358  *
23359  * @details
23360  *
23361  *     Function : rgSCHCmnFindCodeRate
23362  *
23363  *     Processing Steps:
23364  *
23365  *  @param[in]      RgSchCellCb     *cell
23366  *  @param[in]      RgSchDlSf       *dlSf
23367  *  @param[in,out]  RgSchDlRbAlloc  *allocInfo
23368  *  @return  void
23369  **/
23370 #ifdef UNUSED_FUNC
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 #endif
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 UNUSED_FUNC
24201 #ifdef ANSI
24202 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl
24203 (
24204 RgSchCellCb        *cell,
24205 RgSchSFRPoolInfo   **sfrpoolInfo,
24206 RgSchDlSf          *dlSf,
24207 RgSchDlRbAlloc     *allocInfo,
24208 Bool               isUeCellEdge
24209 )
24210 #else
24211 PRIVATE Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
24212 RgSchCellCb        *cell;
24213 RgSchSFRPoolInfo   **sfrpoolInfo;
24214 RgSchDlSf          *dlSf;
24215 RgSchDlRbAlloc     *allocInfo;
24216 Bool               isUeCellEdge;
24217 #endif
24218 {
24219    CmLListCp   *l;
24220    CmLListCp   *l1;
24221    CmLList     *n;
24222    CmLList     *n1;
24223    RgSchSFRPoolInfo  *sfrPool;
24224    RgSchSFRPoolInfo  *sfrCEPool;
24225
24226    U8 tbs;
24227    U8 noLyrs;
24228    RgSchSFRPoolInfo *poolWithMaxAvlblBw = NULLP;
24229    U32 bwAvlbl = 0;
24230    U32 addtnlPRBs = 0;
24231
24232    if (dlSf->bw <= dlSf->bwAlloced)
24233    {
24234       RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, 
24235             "BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
24236       return FALSE;
24237    }
24238
24239    if (dlSf->sfrTotalPoolInfo.ccBwFull == TRUE)
24240    {
24241       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24242             "BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
24243       return FALSE;
24244    }
24245
24246    if ((dlSf->sfrTotalPoolInfo.ceBwFull == TRUE) && (isUeCellEdge))
24247    {
24248       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, 
24249             "BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
24250       return FALSE;
24251    }  
24252
24253    /* We first check if the ue scheduled is a cell edge or cell centre and accordingly check the avaialble
24254       memory in their pool. If the cell centre UE doesnt have Bw available in its pool, then it will check
24255       Bw availability in cell edge pool but the other way around is NOT possible.   */
24256    if(isUeCellEdge)
24257    {   
24258       l = &dlSf->sfrTotalPoolInfo.cePool;
24259    }
24260    else
24261    {
24262       l = &dlSf->sfrTotalPoolInfo.ccPool; 
24263    }     
24264
24265    n = cmLListFirst(l);
24266
24267    while(n)       
24268    {
24269       if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24270       {
24271          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24272
24273          /* MS_FIX for ccpu00123919 : Number of RBs in case of RETX should be same as that of initial transmission. */
24274          if(allocInfo->tbInfo[0].tbCb->txCntr)
24275          {
24276             /* If RB assignment is being done for RETX. Then if reqRbs are   a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24277              * not a multiple of rbgSize then check if lsgRbgDfct exists */
24278             if (allocInfo->rbsReq % cell->rbgSize == 0)
24279             {
24280                if ((sfrPool->type2End == dlSf->type2End) && dlSf->lstRbgDfct)
24281                {
24282                   /* In this scenario we are wasting the last RBG for this dlSf */
24283                   sfrPool->type0End--;
24284                   sfrPool->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24285
24286                   dlSf->lstRbgDfct = 0;
24287
24288                   /*ABHINAV To check if these variables need to be taken care of*/
24289                   dlSf->type0End--;
24290                   dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24291                }
24292             }
24293             else
24294             {
24295                if (dlSf->lstRbgDfct)
24296                {
24297                   /* Check if type0 allocation can cater to this RETX requirement */
24298                   if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24299                   {
24300                      RETVALUE(FALSE);
24301                   }
24302                   else
24303                   {
24304                      if (sfrPool->type2End != dlSf->type2End)   /*Search again for some pool which has the END RBG of the BandWidth*/
24305                      {
24306                         continue;                                       
24307                      }  
24308                   }
24309                }
24310                else
24311                {
24312                   /* cannot allocate same number of required RBs */
24313                   RETVALUE(FALSE);                   
24314                }
24315             }
24316          }
24317
24318          /*rg002.301 ccpu00120391 MOD condition is modified approprialtely to find if rbsReq is less than available RBS*/
24319          if(allocInfo->rbsReq <= (((sfrPool->type0End - sfrPool->type2End + 1)*\
24320                      cell->rbgSize) - dlSf->lstRbgDfct))
24321          {
24322             *sfrpoolInfo = sfrPool;
24323             RETVALUE(TRUE);
24324          }
24325          else
24326          {
24327             if (sfrPool->bw <= sfrPool->bwAlloced + cell->rbgSize)
24328             {
24329                n = cmLListNext(l);
24330                /* If the ue is cell centre then it will simply check the memory available in next pool.
24331                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24332
24333                if((!isUeCellEdge) && (!n->node))
24334                {
24335                   l = &dlSf->sfrTotalPoolInfo.cePool;
24336                   n = cmLListFirst(l);
24337                }
24338
24339                continue; 
24340             }    
24341
24342             /* MS_FIX: Number of RBs in case of RETX should be same as that of initial transmission */
24343             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24344             {
24345                /*rg002.301 ccpu00120391 MOD setting the remaining RBs  for the requested UE*/
24346                allocInfo->rbsReq = (((sfrPool->type0End - sfrPool->type2End + 1)*\
24347                         cell->rbgSize) - dlSf->lstRbgDfct);
24348                RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24349                noLyrs = allocInfo->tbInfo[0].noLyr;
24350                allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24351                *sfrpoolInfo = sfrPool;
24352                RETVALUE(TRUE);
24353             }
24354             else
24355             {
24356                n = cmLListNext(l);
24357
24358                /* If the ue is cell centre then it will simply check the memory available in next pool.
24359                   But if there are no more memory pools available, then cell centre Ue will try to look for memory in cell edge pool */
24360                if((!isUeCellEdge) && (!n->node))
24361                {
24362                   l = &dlSf->sfrTotalPoolInfo.cePool;
24363                   n = cmLListFirst(l);
24364                }
24365
24366                continue;
24367             }
24368
24369          //   RETVALUE(FALSE);
24370          }
24371       }
24372       else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24373       {
24374          sfrPool = (RgSchSFRPoolInfo*)(n->node);
24375          /* This is a Case where a UE was CC and had more RBs allocated than present in CE pool.
24376             In case this UE whn become CE with retx going on, then BW is not sufficient for Retx */
24377          if ((isUeCellEdge) &&
24378             (allocInfo->tbInfo[0].tbCb->txCntr != 0))
24379          {
24380             if(allocInfo->rbsReq > (sfrPool->bw - sfrPool->bwAlloced))
24381             {
24382                /* Adjust CE BW such that Retx alloc is successful */
24383                /* Check if merging CE with adjacent CC pool will be sufficient to process Retx */
24384
24385                /* If no Type 0 allocations are made from this pool */
24386                if (sfrPool->type0End == (((sfrPool->poolendRB + 1) / cell->rbgSize) - 1))
24387                {
24388                   if (sfrPool->adjCCPool &&
24389                         (sfrPool->adjCCPool->type2Start == sfrPool->poolendRB + 1) &&
24390                         (allocInfo->rbsReq <= ((sfrPool->bw - sfrPool->bwAlloced) + 
24391                                                ((sfrPool->adjCCPool->bw - sfrPool->adjCCPool->bwAlloced)))))
24392                   {
24393                      addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24394
24395                      /* Adjusting CE Pool Info */
24396                      sfrPool->bw += addtnlPRBs;
24397                      sfrPool->type0End = ((sfrPool->poolendRB + addtnlPRBs + 1) /
24398                            cell->rbgSize) - 1;
24399
24400                      /* Adjusting CC Pool Info */
24401                      sfrPool->adjCCPool->type2Start += addtnlPRBs;
24402                      sfrPool->adjCCPool->type2End = RGSCH_CEIL(sfrPool->adjCCPool->type2Start, 
24403                            cell->rbgSize);
24404                      sfrPool->adjCCPool->bw -= addtnlPRBs;
24405                      *sfrpoolInfo = sfrPool;
24406                      RETVALUE(TRUE);
24407                   }
24408                }
24409             }
24410          }
24411
24412          /* Check if CC pool is one of the following:
24413           * 1. |CE| + |CC "CCPool2Exists" = TRUE|
24414           * 2. |CC "CCPool2Exists" = FALSE| + |CE| + |CC "CCPool2Exists" = TRUE|
24415           */ 
24416          if(TRUE == sfrPool->CCPool2Exists)
24417          {
24418             l1 = &dlSf->sfrTotalPoolInfo.cePool;
24419             n1 = cmLListFirst(l1); 
24420             sfrCEPool = (RgSchSFRPoolInfo*)(n1->node);
24421             if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced))
24422             {
24423                *sfrpoolInfo = sfrCEPool;
24424                RETVALUE(TRUE);
24425             }
24426             else if(allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))  
24427             {
24428                *sfrpoolInfo = sfrPool;
24429                RETVALUE(TRUE);
24430             }
24431             /* Check if CE and CC boundary has unallocated prbs */
24432             else if ((sfrPool->poolstartRB == sfrPool->type2Start) &&
24433                   (sfrCEPool->type0End  == ((sfrCEPool->poolendRB + 1) / cell->rbgSize) - 1))
24434             {
24435                if(allocInfo->rbsReq <= (sfrCEPool->bw - sfrCEPool->bwAlloced) + 
24436                      (sfrPool->bw - sfrPool->bwAlloced))
24437                {
24438                   /* Checking if BW can be allocated partly from CE pool and partly
24439                    * from CC pool
24440                    */
24441                   addtnlPRBs = allocInfo->rbsReq - (sfrPool->bw - sfrPool->bwAlloced);
24442                   /* Updating CE and CC  type2 parametrs based on the RBs allocated
24443                    * from these pools*/
24444                   sfrPool->type2Start -= addtnlPRBs;
24445                   sfrPool->type2End = RGSCH_CEIL(sfrPool->type2Start, cell->rbgSize);
24446                   sfrPool->bw += addtnlPRBs;
24447                   if (addtnlPRBs == (sfrCEPool->bw - sfrCEPool->bwAlloced))
24448                   {
24449                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24450                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24451                   }
24452                   else
24453                   {
24454                      sfrCEPool->bw -= addtnlPRBs;
24455                      sfrCEPool->type0End = ((sfrCEPool->poolendRB + 1 - addtnlPRBs) / cell->rbgSize) - 1;
24456                   }
24457                   *sfrpoolInfo = sfrPool;
24458                   RETVALUE(TRUE);
24459                }
24460                else if ( bwAvlbl < 
24461                      ((sfrCEPool->bw - sfrCEPool->bwAlloced) +
24462                       (sfrPool->bw - sfrPool->bwAlloced)))
24463                {
24464                   /* All the Prbs from CE BW shall be allocated */
24465                   if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24466                   {
24467                      sfrPool->type2Start   = sfrCEPool->type2Start;
24468                      sfrPool->bw          += sfrCEPool->bw - sfrCEPool->bwAlloced;
24469                      sfrCEPool->type2Start = sfrCEPool->poolendRB + 1;
24470                      sfrCEPool->bwAlloced  = sfrCEPool->bw; 
24471                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE;
24472
24473                      /* set the remaining RBs for the requested UE */
24474                      allocInfo->rbsReq = (sfrPool->bw - sfrPool->bwAlloced);
24475                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24476                      noLyrs = allocInfo->tbInfo[0].noLyr;
24477                      allocInfo->tbInfo[0].bytesReq = 
24478                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24479                      *sfrpoolInfo = sfrPool;               
24480                      RETVALUE(TRUE);
24481                   }
24482                   else
24483                   {
24484                      RETVALUE(FALSE);
24485                   }
24486                }
24487             }
24488          } 
24489
24490          /* Checking if no. of RBs required can be allocated from
24491           * SFR pool. 
24492           * 1. If available return the SFR pool.
24493           * 2. Else update the RBs required parameter based on the 
24494           *    BW available in the pool 
24495           * 3. Return FALSE if no B/W is available. 
24496           */
24497          if (allocInfo->rbsReq <= (sfrPool->bw - sfrPool->bwAlloced))
24498          {
24499             *sfrpoolInfo = sfrPool;
24500             RETVALUE(TRUE);
24501          }
24502          else
24503          {
24504             if(allocInfo->tbInfo[0].tbCb->txCntr == 0)
24505             {
24506                if (bwAvlbl < sfrPool->bw - sfrPool->bwAlloced)
24507                {
24508                   if (isUeCellEdge)
24509                   {
24510                      dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24511                   }
24512                   bwAvlbl = sfrPool->bw - sfrPool->bwAlloced;
24513                   poolWithMaxAvlblBw = sfrPool;
24514                }
24515                n = cmLListNext(l);
24516
24517                if ((isUeCellEdge == FALSE) && (n == NULLP))
24518                {
24519                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24520                   {
24521                      l = &dlSf->sfrTotalPoolInfo.cePool;
24522                      n = cmLListFirst(l);                          
24523                   }
24524                }
24525
24526                if (n == NULLP)
24527                {
24528                   if (bwAvlbl == 0)
24529                   {                                                             
24530                      if (isUeCellEdge)
24531                      {
24532                         dlSf->sfrTotalPoolInfo.ceBwFull = TRUE; 
24533                      }
24534                      else
24535                      {
24536                         dlSf->sfrTotalPoolInfo.ccBwFull = TRUE;  
24537                      }
24538                      RETVALUE(FALSE);
24539                   }
24540                   else
24541                   {
24542                      /* set the remaining RBs for the requested UE */
24543                      allocInfo->rbsReq = poolWithMaxAvlblBw->bw - 
24544                         poolWithMaxAvlblBw->bwAlloced;
24545                      RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24546                      noLyrs = allocInfo->tbInfo[0].noLyr;
24547                      allocInfo->tbInfo[0].bytesReq = 
24548                         rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24549                      *sfrpoolInfo = poolWithMaxAvlblBw;            
24550                      RETVALUE(TRUE);
24551                   }
24552                }                          
24553             }
24554             else
24555             {                   
24556                n = cmLListNext(l);
24557
24558                if ((isUeCellEdge == FALSE) && (n == NULLP))
24559                {
24560                   if(l != &dlSf->sfrTotalPoolInfo.cePool)
24561                   {
24562                      l = &dlSf->sfrTotalPoolInfo.cePool;
24563                      n = cmLListFirst(l);                          
24564                   }
24565                }
24566
24567                if (n == NULLP)
24568                {
24569                   RETVALUE(FALSE);
24570                }
24571             }
24572
24573          }
24574       }   
24575    } 
24576    RETVALUE(FALSE);
24577 }
24578 #endif
24579 #endif /* end of ifndef LTE_TDD*/
24580 /* LTE_ADV_FLAG_REMOVED_END */
24581
24582 /**
24583  * @brief To check if DL BW available for non-DLFS allocation.
24584  *
24585  * @details
24586  *
24587  *     Function : rgSCHCmnNonDlfsUeRbAlloc
24588  *
24589  *     Processing Steps:
24590  *      - Determine availability based on RA Type.
24591  *
24592  *  @param[in]  RgSchCellCb     *cell
24593  *  @param[in]  RgSchDlSf       *dlSf
24594  *  @param[in]  RgSchDlRbAlloc  *allocInfo
24595  *
24596  *  @return Bool
24597  *      -# TRUE
24598  *      -# FALSE
24599  **/
24600 #ifdef UNUSED_FUNC
24601 #ifdef ANSI
24602 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl
24603 (
24604 RgSchCellCb        *cell,
24605 RgSchDlSf          *dlSf,
24606 RgSchDlRbAlloc     *allocInfo
24607 )
24608 #else
24609 PRIVATE Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
24610 RgSchCellCb        *cell;
24611 RgSchDlSf          *dlSf;
24612 RgSchDlRbAlloc     *allocInfo;
24613 #endif
24614 {
24615    U8 tbs;
24616    U8 noLyrs;
24617    U8 ignoredDfctRbg = FALSE;
24618
24619    TRC2(rgSCHCmnNonDlfsBwAvlbl);
24620    if (dlSf->bw <= dlSf->bwAlloced)
24621    {
24622       RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
24623          dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
24624       RETVALUE(FALSE);
24625    }
24626    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
24627    {
24628        /* Fix for ccpu00123919 : Number of RBs in case of RETX should be same as 
24629         * that of initial transmission. */
24630        if(allocInfo->tbInfo[0].tbCb->txCntr)
24631        {
24632           /* If RB assignment is being done for RETX. Then if reqRbs are 
24633            * a multiple of rbgSize then ignore lstRbgDfct. If reqRbs is 
24634            * not a multiple of rbgSize then check if lsgRbgDfct exists */
24635           if (allocInfo->rbsReq % cell->rbgSize == 0)
24636           {
24637              if (dlSf->lstRbgDfct)
24638              {
24639                 /* In this scenario we are wasting the last RBG for this dlSf */
24640                 
24641                 dlSf->type0End--;
24642                 dlSf->bwAlloced += (cell->rbgSize - dlSf->lstRbgDfct);
24643                 /* Fix: MUE_PERTTI_DL */
24644                 dlSf->lstRbgDfct = 0;
24645                 ignoredDfctRbg = TRUE;
24646                 
24647              }
24648           }
24649           else
24650           {
24651              if (dlSf->lstRbgDfct)
24652              {
24653                 /* Check if type0 allocation can cater to this RETX requirement */
24654                 if ((allocInfo->rbsReq % cell->rbgSize) != (cell->rbgSize - dlSf->lstRbgDfct))
24655                 {
24656                    RETVALUE(FALSE);
24657                 }
24658              }
24659              else
24660              {
24661                 /* cannot allocate same number of required RBs */
24662                 RETVALUE(FALSE);                     
24663              }
24664           }
24665        }
24666
24667        /* Condition is modified approprialtely to find
24668         * if rbsReq is less than available RBS*/
24669       if(allocInfo->rbsReq <= (((dlSf->type0End - dlSf->type2End + 1)*\
24670                cell->rbgSize) - dlSf->lstRbgDfct))
24671       {
24672          RETVALUE(TRUE);
24673       }
24674       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24675        * allocation in TDD when requested RBs are more than available RBs*/
24676       else
24677       {
24678           /* MS_WORKAROUND for ccpu00122022 */
24679          if (dlSf->bw < dlSf->bwAlloced + cell->rbgSize)
24680          {
24681             /* ccpu00132358- Re-assigning the values which were updated above 
24682              * if it is RETX and Last  RBG available*/
24683             if(ignoredDfctRbg == TRUE)
24684             {
24685                dlSf->type0End++;
24686                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24687                dlSf->lstRbgDfct = 1;
24688             }
24689
24690
24691             RETVALUE(FALSE);
24692          }
24693          /* Fix: Number of RBs in case of RETX should be same as 
24694           * that of initial transmission. */
24695          if(allocInfo->tbInfo[0].tbCb->txCntr == 0 
24696 #ifdef LTE_ADV
24697             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24698 #endif
24699             )
24700          {
24701             /* Setting the remaining RBs for the requested UE*/
24702             allocInfo->rbsReq = (((dlSf->type0End - dlSf->type2End + 1)*\
24703                         cell->rbgSize) - dlSf->lstRbgDfct);
24704             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24705             noLyrs = allocInfo->tbInfo[0].noLyr;
24706             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24707             /* DwPts Scheduling Changes Start */
24708 #if LTE_TDD
24709             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24710             {   
24711                allocInfo->tbInfo[0].bytesReq = 
24712                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24713             }
24714 #endif            
24715             /* DwPts Scheduling Changes End */
24716          }
24717          else
24718          {
24719                     /* ccpu00132358- Re-assigning the values which were updated above 
24720              * if it is RETX and Last  RBG available*/
24721             if(ignoredDfctRbg == TRUE)
24722             {
24723                dlSf->type0End++;
24724                dlSf->bwAlloced -= (cell->rbgSize - dlSf->lstRbgDfct);
24725                dlSf->lstRbgDfct = 1;
24726             }
24727
24728             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
24729                   allocInfo->rnti);
24730             printf ("RB Alloc failed for LAA TB type 0\n");
24731             RETVALUE(FALSE);
24732          }
24733          RETVALUE(TRUE);
24734       }
24735    }
24736    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
24737    {
24738       if (allocInfo->rbsReq <= (dlSf->bw - dlSf->bwAlloced))
24739       {
24740          RETVALUE(TRUE);
24741       }
24742       /* ccpu00132358:MOD- Removing "ifndef LTE_TDD" for unblocking the RB 
24743        * allocation in TDD when requested RBs are more than available RBs*/
24744       else
24745       {
24746          /* Fix: Number of RBs in case of RETX should be same as 
24747           * that of initial transmission. */
24748          if((allocInfo->tbInfo[0].tbCb->txCntr == 0) 
24749 #ifdef LTE_ADV
24750             && (FALSE == rgSCHLaaIsLaaTB(allocInfo))
24751 #endif
24752             )
24753          {
24754             /* set the remaining RBs for the requested UE */
24755             allocInfo->rbsReq = dlSf->bw - dlSf->bwAlloced;
24756             RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
24757             noLyrs = allocInfo->tbInfo[0].noLyr;
24758             allocInfo->tbInfo[0].bytesReq = rgTbSzTbl[noLyrs-1][tbs][allocInfo->rbsReq - 1]/8;
24759             /* DwPts Scheduling Changes Start */
24760 #ifdef LTE_TDD
24761             if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
24762             {   
24763                allocInfo->tbInfo[0].bytesReq = 
24764                         rgTbSzTbl[noLyrs-1][tbs][RGSCH_MAX(allocInfo->rbsReq*3/4,1) - 1]/8; 
24765             }
24766 #endif            
24767             /* DwPts Scheduling Changes End */
24768          }
24769          else
24770          {
24771             printf ("RB Alloc failed for LAA TB type 2\n");
24772             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24773             RETVALUE(FALSE);
24774          }
24775          /* Fix: Number of RBs in case of RETX should be same as 
24776           * that of initial transmission. */
24777          RETVALUE(TRUE);
24778       }
24779    }
24780    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
24781    RETVALUE(FALSE);
24782 }
24783 #endif
24784 /* LTE_ADV_FLAG_REMOVED_START */
24785 #ifndef LTE_TDD
24786 /**
24787  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24788  *
24789  * @details
24790  *
24791  *     Function : rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24792  *
24793  *     Processing Steps:
24794  *
24795  *  @param[in]  RgSchCellCb     *cell
24796  *  @param[in]  RgSchDlSf       *dlSf
24797  *  @param[in]  U8              rbStrt
24798  *  @param[in]  U8              numRb
24799  *
24800  *  @return Void
24801  **/
24802 #ifdef ANSI
24803 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
24804 (
24805 RgSchCellCb        *cell,
24806 RgSchDlSf          *dlSf,
24807 U8                 rbStrt,
24808 U8                 numRb
24809 )
24810 #else
24811 PUBLIC Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
24812 RgSchCellCb        *cell;
24813 RgSchDlSf          *dlSf;
24814 U8                 rbStrt;
24815 U8                 numRb;
24816 #endif
24817 { 
24818    CmLListCp   *l;
24819    CmLList     *n;
24820    RgSchSFRPoolInfo  *sfrPool;
24821    TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
24822    
24823    l = &dlSf->sfrTotalPoolInfo.ccPool;
24824      
24825    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24826    dlSf->bwAlloced += numRb;
24827    dlSf->type2Start += numRb;
24828    n = cmLListFirst(l);
24829         
24830    while(n->node)
24831    {
24832         sfrPool = (RgSchSFRPoolInfo*)(n->node);
24833         n = cmLListNext(l);
24834          
24835          /* 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   */
24836         if((sfrPool->poolendRB >= dlSf->type2Start) && (sfrPool->type2Start < dlSf->type2Start))
24837         {
24838                 sfrPool->type2End   =  dlSf->type2End;
24839                 sfrPool->bwAlloced  =  dlSf->type2Start - sfrPool->poolstartRB; 
24840                 sfrPool->type2Start =  dlSf->type2Start;
24841         }          
24842         else 
24843         { 
24844                 /* If the pool contains all RBs allocated in this allocation*/
24845                 if(dlSf->type2Start > sfrPool->poolendRB)
24846                 {                
24847                         sfrPool->type2End   =  sfrPool->type0End + 1;
24848                         sfrPool->bwAlloced  =  sfrPool->bw; 
24849                         sfrPool->type2Start =  sfrPool->poolendRB + 1;             
24850                 }  
24851         }
24852       if (!n)
24853       { 
24854          if (l != &dlSf->sfrTotalPoolInfo.cePool)
24855          {
24856             l = &dlSf->sfrTotalPoolInfo.cePool;   
24857             n = cmLListFirst(l);
24858          }
24859          else
24860             RETVOID;
24861       }
24862    }
24863    RETVOID;
24864 }
24865
24866 /**
24867  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24868  *
24869  * @details
24870  *
24871  *     Function : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24872  *
24873  *     Processing Steps:
24874  *
24875  *  @param[in]  RgSchCellCb     *cell
24876  *  @param[in]  RgSchDlSf       *dlSf
24877  *  @param[in]  U8              rbStrt
24878  *  @param[in]  U8              numRb
24879  *
24880  *  @return Void
24881  **/
24882 #ifdef UNUSED_FUNC
24883 #ifdef ANSI
24884 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
24885 (
24886 RgSchCellCb        *cell,
24887 RgSchUeCb          *ue,
24888 RgSchDlSf          *dlSf,
24889 U8                 rbStrt,
24890 U8                 numRb
24891 )
24892 #else
24893 PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
24894 RgSchCellCb        *cell;
24895 RgSchUeCb          *ue;
24896 RgSchDlSf          *dlSf;
24897 U8                 rbStrt;
24898 U8                 numRb;
24899 #endif
24900 {
24901    CmLListCp   *l;
24902    CmLList     *n;
24903    RgSchSFRPoolInfo  *sfrCCPool1 = NULL;
24904    RgSchSFRPoolInfo  *sfrCCPool2 = NULL;
24905    S16 ret = RFAILED;
24906
24907    TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
24908    /* Move the type2End pivot forward */
24909    
24910    
24911    l = &dlSf->sfrTotalPoolInfo.ccPool;
24912    n = cmLListFirst(l);
24913    while(n)
24914    {
24915       sfrCCPool1 = (RgSchSFRPoolInfo*)(n->node);
24916       /* KWork fix */
24917       if (sfrCCPool1 ==  NULLP)
24918             {
24919                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24920                         "sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
24921                RETVALUE(RFAILED);
24922             }
24923       n = cmLListNext(l);
24924       if(n)
24925       {
24926           sfrCCPool2 = (RgSchSFRPoolInfo*)(n->node);
24927           n = cmLListNext(l);
24928       }
24929       if((sfrCCPool1) && (sfrCCPool2))
24930       { 
24931           /* Based on RNTP info, the CC user is assigned high power per subframe basis */
24932           if(((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24933               (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb)) || 
24934              ((dlSf->type2Start >= sfrCCPool2->pwrHiCCRange.startRb) &&
24935               (dlSf->type2Start + numRb < sfrCCPool2->pwrHiCCRange.endRb)))
24936           {
24937                ue->lteAdvUeCb.isCCUePHigh = TRUE;
24938
24939                /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24940                ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24941                if (ret != ROK)
24942                {
24943                     RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
24944                       "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
24945                     RETVALUE(RFAILED);
24946                }
24947            }
24948       }
24949       else
24950       {
24951          if((dlSf->type2Start >= sfrCCPool1->pwrHiCCRange.startRb) &&
24952                (dlSf->type2Start + numRb < sfrCCPool1->pwrHiCCRange.endRb))
24953          {
24954             ue->lteAdvUeCb.isCCUePHigh = TRUE;
24955
24956             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
24957             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
24958             if (ret != ROK)
24959             {
24960                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,   "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():" 
24961                         "rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
24962                RETVALUE(RFAILED);
24963             }
24964          }
24965       }
24966    }
24967    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
24968 #ifndef LTEMAC_SPS
24969    dlSf->bwAlloced += numRb;
24970    /*MS_FIX for ccpu00123918*/
24971    dlSf->type2Start += numRb;
24972 #endif
24973    RETVALUE(ROK);
24974
24975 }
24976 #endif
24977 #endif /* end of ifndef LTE_TDD*/
24978 /* LTE_ADV_FLAG_REMOVED_END */
24979 /**
24980  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
24981  *
24982  * @details
24983  *
24984  *     Function : rgSCHCmnNonDlfsUpdTyp2Alloc
24985  *
24986  *     Processing Steps:
24987  *
24988  *  @param[in]  RgSchCellCb     *cell
24989  *  @param[in]  RgSchDlSf       *dlSf
24990  *  @param[in]  U8              rbStrt
24991  *  @param[in]  U8              numRb
24992  *
24993  *  @return Void
24994  **/
24995 #ifdef ANSI
24996 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc
24997 (
24998 RgSchCellCb        *cell,
24999 RgSchDlSf          *dlSf,
25000 U8                 rbStrt,
25001 U8                 numRb
25002 )
25003 #else
25004 PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
25005 RgSchCellCb        *cell;
25006 RgSchDlSf          *dlSf;
25007 U8                 rbStrt;
25008 U8                 numRb;
25009 #endif
25010 {
25011    TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
25012    /* Move the type2End pivot forward */
25013    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25014 //#ifndef LTEMAC_SPS
25015    dlSf->bwAlloced += numRb;
25016    /*Fix for ccpu00123918*/
25017    dlSf->type2Start += numRb;
25018 //#endif
25019    RETVOID;
25020 }
25021
25022 /**
25023  * @brief To do DL allocation using TYPE0 RA.
25024  *
25025  * @details
25026  *
25027  *     Function : rgSCHCmnNonDlfsType0Alloc
25028  *
25029  *     Processing Steps:
25030  *      - Perform TYPE0 allocation using the RBGs between
25031  *        type0End and type2End.
25032  *      - Build the allocation mask as per RBG positioning.
25033  *      - Update the allocation parameters.
25034  *
25035  *  @param[in]  RgSchCellCb     *cell
25036  *  @param[in]  RgSchDlSf       *dlSf
25037  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25038  *
25039  *  @return Void
25040  **/
25041 #ifdef UNUSED_FUNC
25042 #ifdef ANSI
25043 PRIVATE Void rgSCHCmnNonDlfsType0Alloc
25044 (
25045 RgSchCellCb        *cell,
25046 RgSchDlSf          *dlSf,
25047 RgSchDlRbAlloc     *allocInfo,
25048 RgSchUeCb          *ue
25049 )
25050 #else
25051 PRIVATE Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
25052 RgSchCellCb        *cell;
25053 RgSchDlSf          *dlSf;
25054 RgSchDlRbAlloc     *allocInfo;
25055 RgSchUeCb          *ue;
25056 #endif
25057 {
25058    U32 dlAllocMsk = 0;
25059    U8  rbgFiller = dlSf->lstRbgDfct;
25060    U8  noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25061    //U8  noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
25062    U8  noRbs;
25063    U8  noLyr;
25064    U8  iTbs;
25065    U32          tb1BytesAlloc = 0;
25066    U32          tb2BytesAlloc = 0;
25067    RgSchCmnDlUe *dlUe         = RG_SCH_CMN_GET_DL_UE(ue,cell);
25068
25069    TRC2(rgSCHCmnNonDlfsType0Alloc);
25070    //if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
25071
25072    /* Fix for ccpu00123919*/
25073    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25074    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25075    {
25076       if (--noRbgs == 0)
25077       {
25078          RETVOID;
25079       }
25080       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25081    }
25082
25083    /* Fix for ccpu00138701: Ceilling is using to derive num of RBGs, Therefore, 
25084    *  after this operation,checking Max TB size and Max RBs are not crossed
25085    * if it is crossed then decrement num of RBGs. */
25086    //if((noRbs + rbgFiller) % cell->rbgSize)
25087    if((noRbs > allocInfo->rbsReq) &&
25088          (allocInfo->rbsReq + rbgFiller) % cell->rbgSize)
25089    {/* considering ue category limitation
25090      * due to ceiling */
25091
25092 #ifdef LTE_ADV
25093       if (rgSCHLaaIsLaaTB(allocInfo)== FALSE)
25094 #endif
25095       {
25096          if ((allocInfo->tbInfo[0].schdlngForTb) && (!allocInfo->tbInfo[0].tbCb->txCntr))
25097          {
25098             iTbs = allocInfo->tbInfo[0].iTbs;
25099             noLyr = allocInfo->tbInfo[0].noLyr;
25100             tb1BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25101          }
25102
25103          if ((allocInfo->tbInfo[1].schdlngForTb) && (!allocInfo->tbInfo[1].tbCb->txCntr))
25104          {
25105             iTbs = allocInfo->tbInfo[1].iTbs;
25106             noLyr = allocInfo->tbInfo[1].noLyr;
25107             tb2BytesAlloc = rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25108          }
25109       }
25110       
25111       /* Only Check for New Tx No need for Retx */
25112       if (tb1BytesAlloc || tb2BytesAlloc)
25113       {
25114          if (( ue->dl.aggTbBits >= dlUe->maxTbBits) ||
25115                (tb1BytesAlloc >= dlUe->maxTbSz/8) ||
25116                (tb2BytesAlloc >= dlUe->maxTbSz/8) ||
25117                (noRbs >= dlUe->maxRb))
25118          {
25119             if (--noRbgs == 0)
25120             {
25121                RETVOID;
25122             }
25123             noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25124          }
25125       }
25126    }
25127    /* type0End would have been initially (during subfrm Init) at the bit position
25128     * (cell->noOfRbgs - 1), 0 being the most significant.
25129     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25130    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - dlSf->type0End));
25131    /* Move backwards the type0End pivot */
25132    dlSf->type0End -= noRbgs;
25133    /*Fix for ccpu00123919*/
25134    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25135    /* Update the bwAlloced field accordingly */
25136 //#ifndef LTEMAC_SPS    /* ccpu00129474*/
25137    dlSf->bwAlloced += noRbs;
25138 //#endif
25139    /* Update Type0 Alloc Info */
25140    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25141    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25142    allocInfo->rbsAlloc = noRbs;
25143
25144    /* Update Tb info for each scheduled TB */
25145    iTbs = allocInfo->tbInfo[0].iTbs;
25146    noLyr = allocInfo->tbInfo[0].noLyr;
25147    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25148     * RETX TB Size is same as Init TX TB Size */
25149    if (allocInfo->tbInfo[0].tbCb->txCntr)
25150    {
25151       allocInfo->tbInfo[0].bytesAlloc =
25152          allocInfo->tbInfo[0].bytesReq;
25153    }
25154    else
25155    {
25156       allocInfo->tbInfo[0].bytesAlloc =
25157          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25158       /* DwPts Scheduling Changes Start */
25159 #ifdef LTE_TDD
25160       if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25161       {
25162          allocInfo->tbInfo[0].bytesAlloc =
25163             rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25164       }
25165 #endif      
25166       /* DwPts Scheduling Changes End */
25167    }
25168
25169    if (allocInfo->tbInfo[1].schdlngForTb)
25170    {
25171       iTbs = allocInfo->tbInfo[1].iTbs;
25172       noLyr = allocInfo->tbInfo[1].noLyr;
25173       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25174        * RETX TB Size is same as Init TX TB Size */
25175       if (allocInfo->tbInfo[1].tbCb->txCntr)
25176       {
25177          allocInfo->tbInfo[1].bytesAlloc =
25178             allocInfo->tbInfo[1].bytesReq;
25179       }
25180       else
25181       {
25182          allocInfo->tbInfo[1].bytesAlloc =
25183             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25184          /* DwPts Scheduling Changes Start */
25185 #ifdef LTE_TDD
25186          if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
25187          {
25188             allocInfo->tbInfo[1].bytesAlloc =
25189                rgTbSzTbl[noLyr - 1][iTbs][RGSCH_MAX(noRbs*3/4,1) - 1]/8;
25190          }
25191 #endif      
25192          /* DwPts Scheduling Changes End */
25193       }
25194    }
25195
25196    /* The last RBG which can be smaller than the RBG size is consedered
25197     * only for the first time allocation of TYPE0 UE */
25198    dlSf->lstRbgDfct = 0;
25199    RETVOID;
25200 }
25201 #endif
25202 #ifndef LTE_TDD
25203
25204 /**
25205  * @brief To prepare RNTP value from the PRB allocation (P-High -> 1 and P-Low -> 0)
25206  *
25207  * @details
25208  *
25209  *     Function : rgSCHCmnBuildRntpInfo
25210  *
25211  *     Processing Steps:
25212  *
25213  *  @param[in]  U8                 *rntpPtr
25214  *  @param[in]  U8                 startRb
25215  *  @param[in]  U8                 numRb
25216  *
25217  *  @return Void
25218  **/
25219 #ifdef UNUSED_FUNC
25220 #ifdef ANSI
25221 PRIVATE S16 rgSCHCmnBuildRntpInfo
25222 (
25223 RgSchCellCb        *cell,
25224 U8                 *rntpPtr,
25225 U8                            startRb,
25226 U8                  nmbRb,
25227 U16                 bw
25228 )
25229 #else
25230 PRIVATE S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
25231 RgSchCellCb        *cell;
25232 U8                 *rntpPtr;
25233 U8                            startRb;
25234 U8                  nmbRb;
25235 U16                 bw;
25236 #endif
25237 {
25238    U16 rbPtrStartIdx;              /* Start Index of Octete Buffer to be filled */
25239    U16 rbPtrEndIdx;                /* End Index of Octete Buffer to be filled */
25240    U16 rbBitLoc;                   /* Bit Location to be set as 1 in the current Byte */
25241    U16 nmbRbPerByte;               /* PRB's to be set in the current Byte (in case of multiple Bytes) */
25242
25243    TRC2(rgSCHCmnBuildRntpInfo);
25244
25245    rbPtrStartIdx = (startRb)/8;
25246    rbPtrEndIdx   = (startRb + nmbRb)/8;
25247
25248    if (rntpPtr == NULLP)
25249    {
25250       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
25251                "rgSCHCmnBuildRntpInfo():"
25252                "rntpPtr can't be NULLP (Memory Allocation Failed)");
25253       RETVALUE(RFAILED);
25254    }
25255
25256    while(rbPtrStartIdx <= rbPtrEndIdx)
25257    {
25258       rbBitLoc = (startRb)%8;
25259
25260       /* case 1: startRb and endRb lies in same Byte */
25261       if (rbPtrStartIdx == rbPtrEndIdx)
25262       {
25263          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25264                                      | (((1<<nmbRb)-1)<<rbBitLoc);
25265       }
25266
25267       /* case 2: startRb and endRb lies in different Byte */
25268       if (rbPtrStartIdx != rbPtrEndIdx)
25269       {
25270          nmbRbPerByte = 8 - rbBitLoc;
25271          nmbRb        = nmbRb - nmbRbPerByte;
25272          rntpPtr[rbPtrStartIdx] = rntpPtr[rbPtrStartIdx]
25273                                      | (((1<<nmbRbPerByte)-1)<<rbBitLoc);
25274          startRb = startRb + nmbRbPerByte;
25275       }
25276
25277       rbPtrStartIdx++;
25278    }
25279
25280    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Adding Debug logs */
25281
25282    /* dsfr_pal_fixes ** 25-March-2013 ** SKS ** Adding Debug logs to print RNTP */
25283
25284    RETVALUE(ROK);
25285 }
25286
25287 /**
25288  * @brief To update non-DLFS alloc'n parameters after TYPE2 Allocation.
25289  *
25290  * @details
25291  *
25292  *     Function : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25293  *
25294  *     Processing Steps:
25295  *
25296  *  @param[in]  RgSchCellCb     *cell
25297  *  @param[in]  RgSchDlSf       *dlSf
25298  *  @param[in]  U8              rbStrt
25299  *  @param[in]  U8              numRb
25300  *
25301  *  @return Void
25302  **/
25303 #ifdef ANSI
25304 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
25305 (
25306 RgSchCellCb        *cell,
25307 RgSchUeCb                  *ue,
25308 RgSchDlSf          *dlSf,
25309 RgSchSFRPoolInfo   *sfrPool,
25310 U8                 rbStrt,
25311 U8                 numRb
25312 )
25313 #else
25314 PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
25315 RgSchCellCb        *cell;
25316 RgSchUeCb          *ue;
25317 RgSchDlSf          *dlSf;
25318 RgSchSFRPoolInfo   *sfrPool;
25319 U8                 rbStrt;
25320 U8                 numRb;
25321 #endif
25322 {
25323 #ifndef LTEMAC_SPS
25324    S16 ret;
25325 #endif
25326
25327    TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
25328    dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25329    sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
25330    
25331 #ifndef LTEMAC_SPS
25332    dlSf->type2Start += numRb;
25333    dlSf->bwAlloced += numRb;
25334    
25335    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
25336    {
25337       /* Based on RNTP info, the CC user is assigned high power per subframe basis */
25338       if(FALSE == ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge)
25339       {
25340          if((sfrPool->type2Start >= sfrPool->pwrHiCCRange.startRb) &&
25341                (sfrPool->type2Start + numRb < sfrPool->pwrHiCCRange.endRb))
25342          {
25343             ue->lteAdvUeCb.isCCUePHigh = TRUE;
25344
25345             /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25346             ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25347             if (ret != ROK)
25348             {
25349                RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25350                         "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25351                RETVALUE(RFAILED);
25352             }
25353          }
25354       }
25355       else
25356       {
25357          /* Calling rgSCHCmnBuildRntpInfo function to update RNTP BitMap */
25358          ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
25359          if (ret != ROK)
25360          {
25361             RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
25362                      "rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
25363             RETVALUE(RFAILED);
25364          }
25365       }
25366    }
25367    sfrPool->type2Start += numRb;
25368    sfrPool->bwAlloced += numRb;
25369 #endif 
25370
25371    RETVALUE(ROK);
25372 }
25373
25374 /**
25375  * @brief To do DL allocation using TYPE0 RA.
25376  *
25377  * @details
25378  *
25379  *     Function : rgSCHCmnNonDlfsSFRPoolType0Alloc
25380  *
25381  *     Processing Steps:
25382  *      - Perform TYPE0 allocation using the RBGs between type0End and type2End.
25383  *      - Build the allocation mask as per RBG positioning.
25384  *      - Update the allocation parameters.
25385  *
25386  *  @param[in]  RgSchCellCb     *cell
25387  *  @param[in]  RgSchDlSf       *dlSf
25388  *  @param[in]  RgSchDlRbAlloc  *allocInfo
25389  *
25390  *  @return Void
25391  **/
25392 #ifdef ANSI
25393 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc
25394 (
25395 RgSchCellCb        *cell,
25396 RgSchDlSf          *dlSf,
25397 RgSchSFRPoolInfo   *poolInfo,
25398 RgSchDlRbAlloc     *allocInfo
25399 )
25400 #else
25401 PRIVATE Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
25402 RgSchCellCb        *cell;
25403 RgSchDlSf          *dlSf;
25404 RgSchSFRPoolInfo   *poolInfo;
25405 RgSchDlRbAlloc     *allocInfo;
25406 #endif
25407 {
25408    U32 dlAllocMsk = 0;
25409    U8  rbgFiller = 0;
25410    U8  noRbgs = 0;
25411    U8  noRbs;
25412    U8  noLyr;
25413    U8  iTbs;
25414
25415    TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
25416
25417    if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
25418    {
25419                 if (poolInfo->type0End == dlSf->bw/4)
25420                 {
25421                         rbgFiller = dlSf->lstRbgDfct;
25422                         /* The last RBG which can be smaller than the RBG size is consedered
25423                         * only for the first time allocation of TYPE0 UE */
25424                         dlSf->lstRbgDfct = 0;
25425                 }
25426    }
25427
25428    noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
25429
25430    /* Abhinav to-do start */
25431    /* MS_FIX for ccpu00123919*/
25432    noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25433    if (dlSf->bwAlloced + noRbs > dlSf->bw)
25434    {
25435       if (--noRbgs == 0)
25436       {
25437          RETVOID;
25438       }
25439       noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
25440    }
25441    /* Abhinav to-do end */
25442
25443
25444    
25445    /* type0End would have been initially (during subfrm Init) at the bit position
25446     * (cell->noOfRbgs - 1), 0 being the most significant.
25447     * Getting DlAllocMsk for noRbgs and at the appropriate position */
25448    dlAllocMsk |= (((1 << noRbgs) - 1) << (31 - poolInfo->type0End));
25449    /* Move backwards the type0End pivot */
25450    poolInfo->type0End -= noRbgs;
25451    /*MS_FIX for ccpu00123919*/
25452    /*noRbs = (noRbgs * cell->rbgSize) - rbgFiller;*/
25453    /* Update the bwAlloced field accordingly */
25454    poolInfo->bwAlloced += noRbs + dlSf->lstRbgDfct;
25455    dlSf->bwAlloced += noRbs + dlSf->lstRbgDfct;
25456    
25457    /* Update Type0 Alloc Info */
25458    allocInfo->allocInfo.raType0.numDlAlloc = noRbgs;
25459    allocInfo->allocInfo.raType0.dlAllocBitMask |= dlAllocMsk;
25460    allocInfo->rbsAlloc = noRbs;
25461
25462    /* Update Tb info for each scheduled TB */
25463    iTbs = allocInfo->tbInfo[0].iTbs;
25464    noLyr = allocInfo->tbInfo[0].noLyr;
25465    /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant.
25466     * RETX TB Size is same as Init TX TB Size */
25467    if (allocInfo->tbInfo[0].tbCb->txCntr)
25468    {
25469       allocInfo->tbInfo[0].bytesAlloc =
25470          allocInfo->tbInfo[0].bytesReq;
25471    }
25472    else
25473    {
25474       allocInfo->tbInfo[0].bytesAlloc =
25475          rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
25476    }
25477
25478    if (allocInfo->tbInfo[1].schdlngForTb)
25479    {
25480       iTbs = allocInfo->tbInfo[1].iTbs;
25481       noLyr = allocInfo->tbInfo[1].noLyr;
25482       /* Fix for ccpu00123919: For a RETX TB the iTbs is irrelevant
25483        * RETX TB Size is same as Init TX TB Size */
25484       if (allocInfo->tbInfo[1].tbCb->txCntr)
25485       {
25486          allocInfo->tbInfo[1].bytesAlloc =
25487             allocInfo->tbInfo[1].bytesReq;
25488       }
25489       else
25490       {
25491          allocInfo->tbInfo[1].bytesAlloc =
25492             rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
25493       }
25494    }
25495
25496    /* The last RBG which can be smaller than the RBG size is consedered
25497     * only for the first time allocation of TYPE0 UE */
25498    dlSf->lstRbgDfct = 0;
25499    RETVOID;
25500 }
25501 #endif
25502 /**
25503  * @brief Computes RNTP Info for a subframe.
25504  *
25505  * @details
25506  *
25507  *     Function :  rgSCHCmnNonDlfsDsfrRntpComp 
25508  *
25509  *     Processing Steps:
25510  *      - Computes RNTP info from individual pools.
25511  *
25512  *  @param[in]  RgSchDlSf       *dlSf
25513  *
25514  *  @return  void
25515  
25516  **/
25517 #ifdef ANSI
25518 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp
25519 (
25520 RgSchCellCb         *cell,
25521 RgSchDlSf          *dlSf
25522 )
25523 #else
25524 PRIVATE void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
25525 RgSchCellCb         *cell;
25526 RgSchDlSf          *dlSf;
25527 #endif
25528 {
25529    PRIVATE U16 samples = 0;
25530    U16 i;
25531    U16 bwBytes = (dlSf->bw-1)/8;
25532    RgrLoadInfIndInfo *rgrLoadInf;
25533    U16 len;
25534    U16 ret     = ROK;
25535
25536    TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
25537
25538    len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
25539
25540    /* RNTP info is ORed every TTI and the sample is stored in cell control block */ 
25541    for(i = 0; i <= bwBytes; i++)
25542    {
25543      cell->rntpAggrInfo.val[i] |= dlSf->rntpInfo.val[i];
25544    }
25545    samples = samples + 1;
25546    /* After every 1000 ms, the RNTP info will be sent to application to be further sent to all neighbouring eNB
25547          informing them about the load indication for cell edge users */
25548    if(RG_SCH_MAX_RNTP_SAMPLES == samples)
25549    {
25550       /* ccpu00134492 */
25551       ret = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&rgrLoadInf,
25552                sizeof(RgrLoadInfIndInfo));
25553       if (ret != ROK)
25554       {
25555          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
25556             "allocate memory for sending LoadInfo");
25557          RETVOID;  
25558       }
25559      
25560       rgrLoadInf->u.rntpInfo.pres = cell->rntpAggrInfo.pres;
25561       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25562       rgrLoadInf->u.rntpInfo.len  = len;
25563
25564       /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
25565       rgrLoadInf->u.rntpInfo.val = cell->rntpAggrInfo.val; 
25566       rgrLoadInf->cellId = cell->cellId;
25567
25568       /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
25569       rgrLoadInf->bw = dlSf->bw;
25570       rgrLoadInf->type = RGR_SFR;
25571
25572       ret = rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf);
25573       if(ret == RFAILED)
25574       {
25575          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsDsfrRntpComp():"
25576                   "rgSCHUtlRgrLoadInfInd() returned RFAILED");
25577       }
25578
25579       cmMemset(cell->rntpAggrInfo.val,0,len);
25580       samples = 0;
25581    }
25582  } 
25583 /* LTE_ADV_FLAG_REMOVED_END */
25584
25585 /* LTE_ADV_FLAG_REMOVED_START */
25586 /**
25587  * @brief Performs RB allocation per UE from a pool.
25588  *
25589  * @details
25590  *
25591  *     Function : rgSCHCmnSFRNonDlfsUeRbAlloc
25592  *
25593  *     Processing Steps:
25594  *      - Allocate consecutively available RBs.
25595  *
25596  *  @param[in]  RgSchCellCb     *cell
25597  *  @param[in]  RgSchUeCb       *ue
25598  *  @param[in]  RgSchDlSf       *dlSf
25599  *  @param[out] U8              *isDlBwAvail
25600  *
25601  *  @return  S16
25602  *      -# ROK
25603  *      -# RFAILED
25604  **/
25605 #ifdef UNUSED_FUNC
25606 #ifdef ANSI
25607 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc
25608 (
25609 RgSchCellCb        *cell,
25610 RgSchUeCb          *ue,
25611 RgSchDlSf          *dlSf,
25612 U8                 *isDlBwAvail
25613 )
25614 #else
25615 PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25616 RgSchCellCb        *cell;
25617 RgSchUeCb          *ue;
25618 RgSchDlSf          *dlSf;
25619 U8                 *isDlBwAvail;
25620 #endif
25621 {
25622    RgSchDlRbAlloc  *allocInfo;
25623    RgSchCmnDlUe    *dlUe;
25624    Bool isUECellEdge;
25625    RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
25626
25627    TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
25628
25629    isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
25630
25631    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25632    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25633    *isDlBwAvail = TRUE;
25634
25635    /*Find which pool is available for this UE*/
25636    if (rgSCHCmnNonDlfsSFRBwAvlbl(cell,  &sfrpoolInfo, dlSf, allocInfo, isUECellEdge) != TRUE)
25637    {
25638       /* SFR_FIX - If this is CE UE there may be BW available in CC Pool
25639          So CC UEs will be scheduled */
25640       if (isUECellEdge)
25641       {
25642          *isDlBwAvail = TRUE;
25643       }
25644       else
25645       {
25646          *isDlBwAvail = FALSE;
25647       }
25648       RETVALUE(RFAILED);
25649    }
25650
25651    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX || dlUe->proc->tbInfo[1].isAckNackDtx)
25652    {
25653       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25654    }
25655    else
25656    {
25657       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25658    }
25659    
25660    if (!(allocInfo->pdcch))
25661    {
25662       /* Returning ROK since PDCCH might be available for another UE and further allocations could be done */
25663       RETVALUE(RFAILED);
25664    }
25665    
25666 #ifdef LTEMAC_SPS
25667    allocInfo->rnti = ue->ueId;
25668 #endif
25669
25670    if (allocInfo->raType == RG_SCH_CMN_RA_TYPE2)
25671    {
25672       allocInfo->allocInfo.raType2.isLocal = TRUE;
25673       /* rg004.201 patch - ccpu00109921 fix end */
25674       /* MS_FIX for ccpu00123918*/
25675       allocInfo->allocInfo.raType2.rbStart = (U8)sfrpoolInfo->type2Start;
25676       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
25677       /* rg007.201 - Changes for MIMO feature addition */
25678       /* rg008.201 - Removed dependency on MIMO compile-time flag */
25679       rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrpoolInfo, \
25680             allocInfo->allocInfo.raType2.rbStart, \
25681             allocInfo->allocInfo.raType2.numRb);
25682       allocInfo->rbsAlloc = allocInfo->rbsReq;
25683       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25684    }
25685    else if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
25686    {
25687       rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, sfrpoolInfo, allocInfo);
25688    }
25689 #ifndef LTE_TDD
25690 #ifdef DEBUGP
25691    rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,0);
25692    if(allocInfo->tbInfo[1].schdlngForTb == TRUE)
25693    {
25694       rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,1);
25695    }
25696 #endif
25697 #endif
25698
25699 #if defined(LTEMAC_SPS)
25700    /* Update the sub-frame with new allocation */
25701    dlSf->bwAlloced += allocInfo->rbsReq;
25702 #endif
25703
25704    RETVALUE(ROK);
25705 }
25706 #endif
25707 /* LTE_ADV_FLAG_REMOVED_END */
25708 #endif /* LTE_TDD */
25709
25710 /**
25711  * @brief Performs RB allocation per UE for frequency non-selective cell.
25712  *
25713  * @details
25714  *
25715  *     Function : rgSCHCmnNonDlfsUeRbAlloc
25716  *
25717  *     Processing Steps:
25718  *      - Allocate consecutively available RBs.
25719  *
25720  *  @param[in]  RgSchCellCb     *cell
25721  *  @param[in]  RgSchUeCb       *ue
25722  *  @param[in]  RgSchDlSf       *dlSf
25723  *  @param[out] U8              *isDlBwAvail
25724  *
25725  *  @return  S16
25726  *      -# ROK
25727  *      -# RFAILED
25728  **/
25729 #ifdef ANSI
25730 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc
25731 (
25732 RgSchCellCb        *cell,
25733 RgSchUeCb          *ue,
25734 RgSchDlSf          *dlSf,
25735 U8                 *isDlBwAvail
25736 )
25737 #else
25738 PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
25739 RgSchCellCb        *cell;
25740 RgSchUeCb          *ue;
25741 RgSchDlSf          *dlSf;
25742 U8                 *isDlBwAvail;
25743 #endif
25744 {
25745    RgSchDlRbAlloc  *allocInfo;
25746    RgSchCmnDlUe    *dlUe;
25747 #ifdef LAA_DBG
25748    U32            dbgRbsReq = 0;
25749 #endif
25750    TRC2(rgSCHCmnNonDlfsUeRbAlloc);
25751
25752 #ifdef RG_5GTF
25753    RgSch5gtfUeCb  *ue5gtfCb = &(ue->ue5gtfCb);
25754         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[ue5gtfCb->BeamId]);
25755 #endif
25756    dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
25757    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
25758    *isDlBwAvail = TRUE;
25759
25760         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
25761         {
25762            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25763          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
25764          ue->ueId);
25765            printf("5GTF_ERROR vrbg allocated > 25\n");
25766                 RETVALUE(RFAILED);
25767         }
25768
25769    if (dlUe->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX 
25770        || dlUe->proc->tbInfo[1].isAckNackDtx)
25771    {
25772       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat, TRUE);
25773    }
25774    else
25775    {
25776       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ue, dlSf, dlUe->mimoInfo.cwInfo[0].cqi, allocInfo->dciFormat,FALSE);
25777    }
25778    if (!(allocInfo->pdcch))
25779    {
25780       /* Returning ROK since PDCCH might be available for another UE and
25781        * further allocations could be done */
25782       RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
25783          "5GTF_ERROR : PDCCH allocation failed :ue (%u)",
25784          ue->ueId);
25785            printf("5GTF_ERROR PDCCH allocation failed\n");
25786       RETVALUE(RFAILED);
25787    }
25788 #ifdef RG_5GTF
25789         //maxPrb = RGSCH_MIN((allocInfo->vrbgReq * MAX_5GTF_VRBG_SIZE), ue5gtfCb->maxPrb);
25790    //maxPrb = RGSCH_MIN(maxPrb, 
25791                 //((beamInfo->totVrbgAvail - beamInfo->vrbgStart)* MAX_5GTF_VRBG_SIZE)));
25792         //TODO_SID Need to check for vrbg available after scheduling for same beam.
25793         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
25794         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
25795         //TODO_SID: Setting for max TP
25796         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
25797         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
25798          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
25799         allocInfo->tbInfo[0].tbCb->dlGrnt.SCID = 0;
25800         allocInfo->tbInfo[0].tbCb->dlGrnt.dciFormat = allocInfo->dciFormat;
25801    //Filling temporarily
25802    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
25803    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
25804
25805         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
25806         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
25807         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25808 #endif
25809
25810    RETVALUE(ROK);
25811 }
25812
25813 #ifdef RGR_V1
25814 /**
25815  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
25816  *
25817  * @details
25818  *
25819  *     Function : rgSCHCmnNonDlfsCcchSduAlloc
25820  *
25821  *     Processing Steps:
25822  *     - For each element in the list, Call rgSCHCmnNonDlfsCcchSduRbAlloc().
25823  *        - If allocation is successful, add the ueCb to scheduled list of CCCH
25824  *        SDU.
25825  *        - else, add UeCb to non-scheduled list.
25826  *
25827  *  @param[in]      RgSchCellCb         *cell
25828  *  @param[in, out] RgSchCmnCcchSduRbAlloc *allocInfo
25829  *  @param[in]      U8                  isRetx
25830  *
25831  *  @return  Void
25832  **/
25833 #ifdef ANSI
25834 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc
25835 (
25836 RgSchCellCb         *cell,
25837 RgSchCmnCcchSduRbAlloc *allocInfo,
25838 U8                  isRetx
25839 )
25840 #else
25841 PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
25842 RgSchCellCb         *cell;
25843 RgSchCmnCcchSduRbAlloc *allocInfo;
25844 U8                  isRetx;
25845 #endif
25846 {
25847    S16             ret;
25848    CmLListCp       *ccchSduLst        = NULLP;
25849    CmLListCp       *schdCcchSduLst    = NULLP;
25850    CmLListCp       *nonSchdCcchSduLst = NULLP;
25851    CmLList         *schdLnkNode    = NULLP;
25852    CmLList         *toBeSchdLnk    = NULLP;
25853    RgSchDlSf       *dlSf           = allocInfo->ccchSduDlSf;
25854    RgSchUeCb       *ueCb           = NULLP;
25855    RgSchDlHqProcCb *hqP            = NULLP;
25856    TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
25857
25858    if (isRetx)
25859    {
25860       /* Initialize re-transmitting lists */
25861       ccchSduLst = &(allocInfo->ccchSduRetxLst);
25862       schdCcchSduLst = &(allocInfo->schdCcchSduRetxLst);
25863       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduRetxLst);
25864    }
25865    else
25866    {
25867       /* Initialize transmitting lists */
25868       ccchSduLst = &(allocInfo->ccchSduTxLst);
25869       schdCcchSduLst = &(allocInfo->schdCcchSduTxLst);
25870       nonSchdCcchSduLst = &(allocInfo->nonSchdCcchSduTxLst);
25871    }
25872
25873    /* Perform allocaations  for the list */
25874    toBeSchdLnk = cmLListFirst(ccchSduLst);
25875    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
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       ret = rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf);
25882       if (ret != ROK)
25883       {
25884          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
25885           * list and return */
25886          do
25887          {
25888             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
25889             ueCb = hqP->hqE->ue;
25890             schdLnkNode = &hqP->schdLstLnk;
25891             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
25892             cmLListAdd2Tail(nonSchdCcchSduLst, schdLnkNode);
25893             toBeSchdLnk = toBeSchdLnk->next;
25894          } while(toBeSchdLnk);
25895          RETVOID;
25896       }
25897
25898       /* Allocation successful: Add UE to the scheduled list */
25899       cmLListAdd2Tail(schdCcchSduLst, schdLnkNode);
25900    }
25901
25902
25903    RETVOID;
25904 }
25905
25906 /**
25907  * @brief Performs RB allocation for CcchSdu for frequency non-selective cell.
25908  *
25909  * @details
25910  *
25911  *     Function : rgSCHCmnNonDlfsCcchSduRbAlloc
25912  *
25913  *     Processing Steps:
25914  *     - Fetch PDCCH
25915  *     - Allocate consecutively available RBs
25916  *
25917  *  @param[in] RgSchCellCb     *cell
25918  *  @param[in] RgSchUeCb       *ueCb
25919  *  @param[in] RgSchDlSf       *dlSf
25920  *  @return  S16
25921  *      -# ROK
25922  *      -# RFAILED
25923  **/
25924 #ifdef ANSI
25925 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc
25926 (
25927 RgSchCellCb        *cell,
25928 RgSchUeCb          *ueCb,
25929 RgSchDlSf          *dlSf
25930 )
25931 #else
25932 PRIVATE S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
25933 RgSchCellCb        *cell;
25934 RgSchUeCb          *ueCb;
25935 RgSchDlSf          *dlSf;
25936 #endif
25937 {
25938    RgSchDlRbAlloc  *allocInfo;
25939    RgSchCmnDlUe         *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
25940
25941    TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
25942
25943
25944    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
25945
25946    /* [ccpu00138802]-MOD-If Bw is less than required, return fail
25947       It will be allocated in next TTI */
25948 #ifdef LTEMAC_SPS
25949    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
25950          (dlSf->bwAlloced == dlSf->bw))
25951 #else
25952    if((dlSf->bwAlloced == dlSf->bw) ||
25953       (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
25954 #endif
25955    {
25956       RETVALUE(RFAILED);
25957    }
25958    /* Retrieve PDCCH */
25959    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
25960    if (ueDl->proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
25961    {
25962       /*      allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, dlSf, y, ueDl->cqi,
25963        *      TFU_DCI_FORMAT_1A, TRUE);*/
25964       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, TRUE);
25965    }
25966    else
25967    {
25968       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, ueCb, dlSf, ueDl->mimoInfo.cwInfo[0].cqi, TFU_DCI_FORMAT_1A, FALSE);
25969    }
25970    if (!(allocInfo->pdcch))
25971    {
25972       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
25973       RETVALUE(RFAILED);
25974    }
25975
25976    /* Update allocation information */
25977    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
25978    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
25979    allocInfo->allocInfo.raType2.isLocal = TRUE;
25980
25981       /*Fix for ccpu00123918*/
25982       /* Push this harq process back to the free queue */
25983       allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
25984       allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
25985       allocInfo->rbsAlloc = allocInfo->rbsReq;
25986       allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
25987       /* Update the sub-frame with new allocation */
25988       /* ccpu00129469 */
25989       /* LTE_ADV_FLAG_REMOVED_START */
25990 #ifndef LTE_TDD
25991       if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
25992       {
25993          rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf,
25994                allocInfo->allocInfo.raType2.rbStart,
25995                allocInfo->allocInfo.raType2.numRb);
25996       }
25997       else
25998 #endif /* end of ifndef LTE_TDD*/
25999       {
26000          rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, 
26001                allocInfo->allocInfo.raType2.rbStart, 
26002                allocInfo->allocInfo.raType2.numRb);
26003       }
26004
26005    /* LTE_ADV_FLAG_REMOVED_END */
26006    /* ccpu00131941 - bwAlloced is updated from SPS bandwidth */  
26007
26008
26009    RETVALUE(ROK);
26010 }
26011 #endif
26012
26013 /**
26014  * @brief Performs RB allocation for Msg4 for frequency non-selective cell.
26015  *
26016  * @details
26017  *
26018  *     Function : rgSCHCmnNonDlfsMsg4RbAlloc
26019  *
26020  *     Processing Steps:
26021  *     - Fetch PDCCH
26022  *     - Allocate consecutively available RBs
26023  *
26024  *  @param[in] RgSchCellCb     *cell
26025  *  @param[in] RgSchRaCb       *raCb
26026  *  @param[in] RgSchDlSf       *dlSf
26027  *  @return  S16
26028  *      -# ROK
26029  *      -# RFAILED
26030  **/
26031 #ifdef ANSI
26032 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc
26033 (
26034 RgSchCellCb        *cell,
26035 RgSchRaCb          *raCb,
26036 RgSchDlSf          *dlSf
26037 )
26038 #else
26039 PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
26040 RgSchCellCb        *cell;
26041 RgSchRaCb          *raCb;
26042 RgSchDlSf          *dlSf;
26043 #endif
26044 {
26045    RgSchDlRbAlloc  *allocInfo;
26046    TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
26047
26048
26049    allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
26050
26051 #ifdef RG_5GTF
26052         RgSchSfBeamInfo  *beamInfo = &(dlSf->sfBeamInfo[0]);
26053         if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
26054         {
26055            RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
26056          "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
26057          raCb->ue->ueId);
26058            printf("5GTF_ERROR vrbg allocated > 25\n");
26059                 RETVALUE(RFAILED);
26060         }
26061 #endif
26062 #ifdef LTEMAC_SPS
26063    if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
26064          (dlSf->bwAlloced == dlSf->bw))
26065 #else
26066    if((dlSf->bwAlloced == dlSf->bw) ||
26067             (allocInfo->rbsReq > (dlSf->bw - dlSf->bwAlloced)))
26068 #endif
26069    {
26070
26071       RETVALUE(RFAILED);
26072    }
26073
26074    /* DTX Changes: One Variable is passed to check whether it is DTX or Not */
26075    if (raCb->dlHqE->msg4Proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX)
26076    {
26077       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, TRUE);
26078    }
26079    else
26080    {
26081       allocInfo->pdcch = rgSCHCmnPdcchAlloc(cell, raCb->ue, dlSf, raCb->ccchCqi, TFU_DCI_FORMAT_B1, FALSE);
26082    }
26083    if (!(allocInfo->pdcch))
26084    {
26085       /* Returning RFAILED since PDCCH not available for any CCCH allocations */
26086       RETVALUE(RFAILED);
26087    }
26088    
26089 #ifndef RG_5GTF
26090  /* SR_RACH_STATS : MSG4 TX Failed */
26091    allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26092
26093    /* Update allocation information */
26094    allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
26095    allocInfo->raType = RG_SCH_CMN_RA_TYPE2;
26096    allocInfo->allocInfo.raType2.isLocal = TRUE;
26097
26098
26099         /*Fix for ccpu00123918*/
26100         allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
26101         allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
26102         /* LTE_ADV_FLAG_REMOVED_START */
26103 #ifndef LTE_TDD
26104         if (cell->lteAdvCb.sfrCfg.status == RGR_ENABLE)
26105         {
26106           rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, \
26107                 allocInfo->allocInfo.raType2.rbStart, \
26108                 allocInfo->allocInfo.raType2.numRb);
26109         }
26110         else
26111 #endif /* end of ifndef LTE_TDD */
26112         {
26113           rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, \
26114                 allocInfo->allocInfo.raType2.rbStart, \
26115                 allocInfo->allocInfo.raType2.numRb);
26116         }
26117         /* LTE_ADV_FLAG_REMOVED_END */
26118
26119    allocInfo->rbsAlloc = allocInfo->rbsReq;
26120    allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26121
26122 #else
26123
26124   allocInfo->pdcch->dci.u.format1aInfo.t.pdschInfo.isTBMsg4 = TRUE;
26125
26126         allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart = beamInfo->vrbgStart;
26127         allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg = allocInfo->vrbgReq;
26128
26129    /* Update allocation information */
26130    allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26131
26132         allocInfo->tbInfo[0].tbCb->dlGrnt.xPDSCHRange = 1;      
26133         allocInfo->tbInfo[0].tbCb->dlGrnt.rbAssign = rgSCHCmnCalcRiv(MAX_5GTF_VRBG, 
26134          allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart, allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg);
26135
26136    allocInfo->tbInfo[0].tbCb->dlGrnt.rbStrt = (allocInfo->tbInfo[0].tbCb->dlGrnt.vrbgStart * MAX_5GTF_VRBG_SIZE);
26137    allocInfo->tbInfo[0].tbCb->dlGrnt.numRb = (allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg * MAX_5GTF_VRBG_SIZE);
26138
26139
26140         beamInfo->vrbgStart += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg;
26141         beamInfo->totVrbgAllocated += allocInfo->tbInfo[0].tbCb->dlGrnt.numVrbg; 
26142         allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
26143
26144 #endif
26145
26146    RETVALUE(ROK);
26147 }
26148
26149 /**
26150  * @brief Performs RB allocation for Msg4 lists of frequency non-selective cell.
26151  *
26152  * @details
26153  *
26154  *     Function : rgSCHCmnNonDlfsMsg4Alloc
26155  *
26156  *     Processing Steps:
26157  *     - For each element in the list, Call rgSCHCmnNonDlfsMsg4RbAlloc().
26158  *        - If allocation is successful, add the raCb to scheduled list of MSG4.
26159  *        - else, add RaCb to non-scheduled list.
26160  *
26161  *  @param[in]      RgSchCellCb         *cell
26162  *  @param[in, out] RgSchCmnMsg4RbAlloc *allocInfo
26163  *  @param[in]      U8                  isRetx
26164  *
26165  *  @return  Void
26166  **/
26167 #ifdef ANSI
26168 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc
26169 (
26170 RgSchCellCb         *cell,
26171 RgSchCmnMsg4RbAlloc *allocInfo,
26172 U8                  isRetx
26173 )
26174 #else
26175 PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
26176 RgSchCellCb         *cell;
26177 RgSchCmnMsg4RbAlloc *allocInfo;
26178 U8                  isRetx;
26179 #endif
26180 {
26181    S16             ret;
26182    CmLListCp       *msg4Lst        = NULLP;
26183    CmLListCp       *schdMsg4Lst    = NULLP;
26184    CmLListCp       *nonSchdMsg4Lst = NULLP;
26185    CmLList         *schdLnkNode    = NULLP;
26186    CmLList         *toBeSchdLnk    = NULLP;
26187    RgSchDlSf       *dlSf           = allocInfo->msg4DlSf;
26188    RgSchRaCb       *raCb           = NULLP;
26189    RgSchDlHqProcCb *hqP            = NULLP;
26190    TRC2(rgSCHCmnNonDlfsMsg4Alloc);
26191
26192    if (isRetx)
26193    {
26194       /* Initialize re-transmitting lists */
26195       msg4Lst = &(allocInfo->msg4RetxLst);
26196       schdMsg4Lst = &(allocInfo->schdMsg4RetxLst);
26197       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4RetxLst);
26198    }
26199    else
26200    {
26201       /* Initialize transmitting lists */
26202       msg4Lst = &(allocInfo->msg4TxLst);
26203       schdMsg4Lst = &(allocInfo->schdMsg4TxLst);
26204       nonSchdMsg4Lst = &(allocInfo->nonSchdMsg4TxLst);
26205    }
26206
26207    /* Perform allocaations  for the list */
26208    toBeSchdLnk = cmLListFirst(msg4Lst);
26209    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
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       ret = rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf);
26216       if (ret != ROK)
26217       {
26218          /* Allocation failed: Add remaining MSG4 nodes to non-scheduled
26219           * list and return */
26220          do
26221          {
26222             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26223             raCb = hqP->hqE->raCb;
26224             schdLnkNode = &hqP->schdLstLnk;
26225             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26226             cmLListAdd2Tail(nonSchdMsg4Lst, schdLnkNode);
26227             toBeSchdLnk = toBeSchdLnk->next;
26228          } while(toBeSchdLnk);
26229          RETVOID;
26230       }
26231
26232       /* Allocation successful: Add UE to the scheduled list */
26233       cmLListAdd2Tail(schdMsg4Lst, schdLnkNode);
26234       if (isRetx)
26235       {
26236       }
26237    }
26238
26239
26240    RETVOID;
26241 }
26242
26243 /**
26244  * @brief Performs RB allocation for the list of UEs of a frequency
26245  * non-selective cell.
26246  *
26247  * @details
26248  *
26249  *     Function : rgSCHCmnNonDlfsDedRbAlloc
26250  *
26251  *     Processing Steps:
26252  *     - For each element in the list, Call rgSCHCmnNonDlfsUeRbAlloc().
26253  *        - If allocation is successful, add the ueCb to scheduled list of UEs.
26254  *        - else, add ueCb to non-scheduled list of UEs.
26255  *
26256  *  @param[in]      RgSchCellCb        *cell
26257  *  @param[in, out] RgSchCmnUeRbAlloc  *allocInfo
26258  *  @param[in]      CmLListCp          *ueLst,
26259  *  @param[in, out] CmLListCp          *schdHqPLst,
26260  *  @param[in, out] CmLListCp          *nonSchdHqPLst
26261  *
26262  *  @return  Void
26263  **/
26264 #ifdef ANSI
26265 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc
26266 (
26267 RgSchCellCb        *cell,
26268 RgSchCmnUeRbAlloc  *allocInfo,
26269 CmLListCp          *ueLst,
26270 CmLListCp          *schdHqPLst,
26271 CmLListCp          *nonSchdHqPLst
26272 )
26273 #else
26274 PUBLIC Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
26275         schdHqPLst, nonSchdHqPLst)
26276 RgSchCellCb        *cell;
26277 RgSchCmnUeRbAlloc  *allocInfo;
26278 CmLListCp          *ueLst;
26279 CmLListCp          *schdHqPLst;
26280 CmLListCp          *nonSchdHqPLst;
26281 #endif
26282 {
26283    S16             ret;
26284    CmLList         *schdLnkNode  = NULLP;
26285    CmLList         *toBeSchdLnk  = NULLP;
26286    RgSchDlSf       *dlSf         = allocInfo->dedDlSf;
26287    RgSchUeCb       *ue           = NULLP;
26288    RgSchDlHqProcCb *hqP          = NULLP;
26289    U8              isDlBwAvail;
26290    TRC2(rgSCHCmnNonDlfsDedRbAlloc);
26291
26292
26293    /* Perform allocaations  for the list */
26294    toBeSchdLnk = cmLListFirst(ueLst);
26295    for (; toBeSchdLnk; toBeSchdLnk = toBeSchdLnk->next)
26296    {
26297       hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26298       ue = hqP->hqE->ue;
26299       schdLnkNode = &hqP->schdLstLnk;
26300       RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26301
26302       ret = rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, &isDlBwAvail);
26303       if (!isDlBwAvail)
26304       {
26305          /* Allocation failed: Add remaining UEs to non-scheduled
26306           * list and return */
26307          do
26308          {
26309             hqP = (RgSchDlHqProcCb *)(toBeSchdLnk->node);
26310             ue = hqP->hqE->ue;
26311             schdLnkNode = &hqP->schdLstLnk;
26312             RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
26313             cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26314             toBeSchdLnk = toBeSchdLnk->next;
26315          } while(toBeSchdLnk);
26316          break; 
26317       }
26318
26319       if (ret == ROK)
26320       {
26321 #if defined (TENB_STATS) && defined (RG_5GTF)
26322          cell->tenbStats->sch.dl5gtfRbAllocPass++;
26323 #endif
26324          /* Allocation successful: Add UE to the scheduled list */
26325          cmLListAdd2Tail(schdHqPLst, schdLnkNode);
26326       }
26327       else
26328       {
26329 #if defined (TENB_STATS) && defined (RG_5GTF)
26330          cell->tenbStats->sch.dl5gtfRbAllocFail++;
26331 #endif
26332          /* Allocation failed : Add UE to the non-scheduled list */
26333                         printf("5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
26334          cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
26335       }
26336    }
26337
26338    RETVOID;
26339 }
26340
26341 /**
26342  * @brief Handles RB allocation for frequency non-selective cell.
26343  *
26344  * @details
26345  *
26346  *     Function : rgSCHCmnNonDlfsRbAlloc
26347  *
26348  *     Invoking Module Processing:
26349  *      - SCH shall invoke this if downlink frequency selective is disabled for
26350  *        the cell for RB allocation.
26351  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
26352  *        estimate and subframe for each allocation to be made to SCH.
26353  *
26354  *     Processing Steps:
26355  *     - Allocate sequentially for common channels.
26356  *     - For transmitting and re-transmitting UE list.
26357  *      - For each UE:
26358  *       - Perform wide-band allocations for UE in increasing order of
26359  *         frequency.
26360  *       - Determine Imcs for the allocation.
26361  *       - Determine RA type.
26362  *       - Determine DCI format.
26363  *
26364  *  @param[in]  RgSchCellCb        *cell
26365  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
26366  *  @return  Void
26367  **/
26368
26369 #ifdef ANSI
26370 PUBLIC Void rgSCHCmnNonDlfsRbAlloc
26371 (
26372 RgSchCellCb           *cell,
26373 RgSchCmnDlRbAllocInfo *allocInfo
26374 )
26375 #else
26376 PUBLIC Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
26377 RgSchCellCb           *cell;
26378 RgSchCmnDlRbAllocInfo *allocInfo;
26379 #endif
26380 {
26381    U8                 raRspCnt = 0;
26382    RgSchDlRbAlloc     *reqAllocInfo;
26383    TRC2(rgSCHCmnNonDlfsRbAlloc);
26384
26385    /* Allocate for MSG4 retransmissions */
26386    if (allocInfo->msg4Alloc.msg4RetxLst.count)
26387    {
26388       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
26389       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), TRUE);
26390    }
26391
26392    /* Allocate for MSG4 transmissions */
26393    /* Assuming all the nodes in the list need allocations: rbsReq is valid */
26394    if (allocInfo->msg4Alloc.msg4TxLst.count)
26395    {
26396       printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
26397       rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), FALSE);
26398    }
26399 #ifdef RGR_V1
26400    /* Allocate for CCCH SDU (received after guard timer expiry)
26401     * retransmissions */
26402    if (allocInfo->ccchSduAlloc.ccchSduRetxLst.count)
26403    {
26404       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26405       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), TRUE);
26406    }
26407
26408    /* Allocate for CCCD SDU transmissions */
26409    /* Allocate for CCCH SDU (received after guard timer expiry) transmissions */
26410    if (allocInfo->ccchSduAlloc.ccchSduTxLst.count)
26411    {
26412       printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
26413       rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), FALSE);
26414    }
26415 #endif
26416
26417    /* Allocate for Random access response */
26418    for (raRspCnt = 0; raRspCnt < RG_SCH_CMN_MAX_CMN_PDCCH; ++raRspCnt)
26419    {
26420       /* Assuming that the requests will be filled in sequentially */
26421       reqAllocInfo = &(allocInfo->raRspAlloc[raRspCnt]);
26422       if (!reqAllocInfo->rbsReq)
26423       {
26424          break;
26425       }
26426       printf("5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
26427    //   if ((rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo)) != ROK)
26428       if ((rgSCHCmnNonDlfsCmnRbAllocRar(cell, reqAllocInfo)) != ROK)
26429       {
26430          break;
26431       }
26432    }
26433
26434    /* Allocate for RETX+TX UEs */
26435    if(allocInfo->dedAlloc.txRetxHqPLst.count)
26436    {
26437       printf("5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
26438       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26439             &(allocInfo->dedAlloc.txRetxHqPLst),
26440             &(allocInfo->dedAlloc.schdTxRetxHqPLst),
26441             &(allocInfo->dedAlloc.nonSchdTxRetxHqPLst));
26442    }
26443
26444    if((allocInfo->dedAlloc.retxHqPLst.count))
26445    {
26446       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26447             &(allocInfo->dedAlloc.retxHqPLst),
26448             &(allocInfo->dedAlloc.schdRetxHqPLst),
26449             &(allocInfo->dedAlloc.nonSchdRetxHqPLst));
26450    }
26451
26452    /* Allocate for transmitting UEs */
26453    if((allocInfo->dedAlloc.txHqPLst.count))
26454    {
26455       rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
26456             &(allocInfo->dedAlloc.txHqPLst),
26457             &(allocInfo->dedAlloc.schdTxHqPLst),
26458             &(allocInfo->dedAlloc.nonSchdTxHqPLst));
26459    }
26460    {
26461       RgSchCmnCell  *cmnCell = RG_SCH_CMN_GET_CELL(cell);
26462       if ((allocInfo->dedAlloc.txRetxHqPLst.count + 
26463                allocInfo->dedAlloc.retxHqPLst.count + 
26464                allocInfo->dedAlloc.txHqPLst.count) > 
26465             cmnCell->dl.maxUePerDlSf)
26466       {
26467 #ifndef ALIGN_64BIT
26468          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26469                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %ld retx %ld tx %ld\n",
26470                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26471                   allocInfo->dedAlloc.retxHqPLst.count,
26472                   allocInfo->dedAlloc.txHqPLst.count));
26473 #else
26474          RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
26475                   " scheduler exceed maximumUePerDlSf(%u)tx-retx %d retx %d tx %d\n",
26476                   cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
26477                   allocInfo->dedAlloc.retxHqPLst.count,
26478                   allocInfo->dedAlloc.txHqPLst.count));
26479 #endif
26480       }
26481    }
26482 #ifndef LTE_TDD
26483    /* LTE_ADV_FLAG_REMOVED_START */
26484    if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
26485    {    
26486       printf("5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
26487       rgSCHCmnNonDlfsDsfrRntpComp(cell, allocInfo->dedAlloc.dedDlSf); 
26488    }  
26489    /* LTE_ADV_FLAG_REMOVED_END */
26490 #endif /* LTE_TDD */
26491    RETVOID;
26492 }
26493
26494 /***********************************************************
26495  *
26496  *     Func : rgSCHCmnCalcRiv
26497  *
26498  *     Desc : This function calculates RIV.
26499  *
26500  *     Ret  : None.
26501  *
26502  *     Notes: None.
26503  *
26504  *     File : rg_sch_utl.c
26505  *
26506  **********************************************************/
26507 #ifdef LTEMAC_SPS
26508 #ifdef ANSI
26509 PUBLIC U32 rgSCHCmnCalcRiv
26510 (
26511 U8           bw,
26512 U8           rbStart,
26513 U8           numRb
26514 )
26515 #else
26516 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26517 U8           bw;
26518 U8           rbStart;
26519 U8           numRb;
26520 #endif
26521 #else
26522 #ifdef ANSI
26523 PUBLIC U32 rgSCHCmnCalcRiv
26524 (
26525 U8           bw,
26526 U8           rbStart,
26527 U8           numRb
26528 )
26529 #else
26530 PUBLIC U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
26531 U8           bw;
26532 U8           rbStart;
26533 U8           numRb;
26534 #endif
26535 #endif
26536 {
26537    U8           numRbMinus1 = numRb - 1;
26538    U32          riv;
26539
26540    TRC2(rgSCHCmnCalcRiv);
26541
26542    if (numRbMinus1 <= bw/2)
26543    {
26544       riv = bw * numRbMinus1 + rbStart;
26545    }
26546    else
26547    {
26548       riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
26549    }
26550    RETVALUE(riv);
26551 } /* rgSCHCmnCalcRiv */
26552
26553 #ifdef LTE_TDD
26554 /**
26555  * @brief This function allocates and copies the RACH response scheduling
26556  *        related information into cell control block.
26557  *
26558  * @details
26559  *
26560  *     Function: rgSCHCmnDlCpyRachInfo
26561  *     Purpose:  This function allocates and copies the RACH response
26562  *               scheduling related information into cell control block
26563  *               for each DL subframe.
26564  *
26565  *
26566  *     Invoked by: Scheduler
26567  *
26568  *  @param[in]  RgSchCellCb*           cell
26569  *  @param[in]  RgSchTddRachRspLst     rachRspLst[][RGSCH_NUM_SUB_FRAMES]
26570  *  @param[in]  U8                     raArrSz
26571  *  @return     S16
26572  *
26573  **/
26574 #ifdef ANSI
26575 PRIVATE S16 rgSCHCmnDlCpyRachInfo
26576 (
26577 RgSchCellCb                *cell,
26578 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES],
26579 U8                         raArrSz
26580 )
26581 #else
26582 PRIVATE S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
26583 RgSchCellCb                *cell;
26584 RgSchTddRachRspLst         rachRspLst[][RGSCH_NUM_SUB_FRAMES];
26585 U8                         raArrSz;
26586 #endif
26587 {
26588    U8                   ulDlCfgIdx = cell->ulDlCfgIdx;
26589    U8                   sfNum;
26590    S16                  sfnIdx;
26591    U16                  subfrmIdx;
26592    U8                   numRfs;
26593    U8                   numSubfrms;
26594    U8                   sfcount;
26595    S16                   ret;
26596
26597    TRC2(rgSCHCmnDlCpyRachInfo);
26598
26599    /* Allocate RACH response information for each DL
26600     * subframe in a radio frame */
26601    ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&cell->rachRspLst,
26602          rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1] *
26603          sizeof(RgSchTddRachRspLst));
26604    if (ret != ROK)
26605    {
26606       RETVALUE(ret);
26607    }
26608
26609    for(sfnIdx=raArrSz-1; sfnIdx>=0; sfnIdx--)
26610    {
26611       for(subfrmIdx=0; subfrmIdx < RGSCH_NUM_SUB_FRAMES; subfrmIdx++)
26612       {
26613          subfrmIdx = rgSchTddHighDlSubfrmIdxTbl[ulDlCfgIdx][subfrmIdx];
26614          if(subfrmIdx == RGSCH_NUM_SUB_FRAMES)
26615          {
26616             break;
26617          }
26618
26619          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rachRspLst[sfnIdx],subfrmIdx);
26620          numSubfrms =
26621             rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26622
26623          RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchTddNumDlSubfrmTbl[ulDlCfgIdx],subfrmIdx);
26624          sfNum = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][subfrmIdx]-1;
26625          numRfs = cell->rachRspLst[sfNum].numRadiofrms;
26626          /* For each DL subframe in which RACH response can
26627           * be sent is updated */
26628          if(numSubfrms > 0)
26629          {
26630             cell->rachRspLst[sfNum].rachRsp[numRfs].sfnOffset =
26631                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].sfnOffset;
26632             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26633             {
26634                cell->rachRspLst[sfNum].rachRsp[numRfs].\
26635                   subframe[sfcount] =
26636                   rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].\
26637                   subframe[sfcount];
26638             }
26639             cell->rachRspLst[sfNum].rachRsp[numRfs].numSubfrms =
26640                rachRspLst[sfnIdx][subfrmIdx].rachRsp[0].numSubfrms;
26641             cell->rachRspLst[sfNum].numRadiofrms++;
26642          }
26643
26644          /* Copy the subframes to be deleted at ths subframe */
26645          numSubfrms =
26646             rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26647          if(numSubfrms > 0)
26648          {
26649             cell->rachRspLst[sfNum].delInfo.sfnOffset =
26650                rachRspLst[sfnIdx][subfrmIdx].delInfo.sfnOffset;
26651             for(sfcount=0; sfcount < numSubfrms; sfcount++)
26652             {
26653                cell->rachRspLst[sfNum].delInfo.subframe[sfcount] =
26654                   rachRspLst[sfnIdx][subfrmIdx].delInfo.subframe[sfcount];
26655             }
26656             cell->rachRspLst[sfNum].delInfo.numSubfrms =
26657                rachRspLst[sfnIdx][subfrmIdx].delInfo.numSubfrms;
26658          }
26659       }
26660    }
26661    RETVALUE(ROK);
26662 }
26663 #endif
26664 /**
26665  * @brief This function determines the iTbs based on the new CFI, 
26666  *        CQI and BLER based delta iTbs 
26667  *
26668  * @details
26669  *
26670  *     Function: rgSchCmnFetchItbs
26671  *     Purpose:  Fetch the new iTbs when CFI changes.
26672  *
26673  *  @param[in]  RgSchCellCb           *cell
26674  *  @param[in]  RgSchCmnDlUe          *ueDl
26675  *  @param[in]  U8                    cqi
26676  *
26677  *  @return S32 iTbs
26678  *
26679  **/
26680 #ifdef LTE_TDD
26681 #ifdef ANSI
26682 PRIVATE S32 rgSchCmnFetchItbs 
26683 (
26684 RgSchCellCb        *cell,
26685 RgSchCmnDlUe       *ueDl,
26686 RgSchDlSf          *subFrm,
26687 U8                 cqi,
26688 U8                 cfi,
26689 U8                 cwIdx,
26690 U8                 noLyr
26691 )
26692 #else
26693 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
26694 RgSchCellCb        *cell;
26695 RgSchCmnDlUe       *ueDl; 
26696 RgSchDlSf          *subFrm;
26697 U8                 cqi;
26698 U8                 cfi;
26699 U8                 cwIdx;
26700 U8                 noLyr;
26701 #endif
26702 #else
26703 #ifdef ANSI
26704 PRIVATE S32 rgSchCmnFetchItbs 
26705 (
26706 RgSchCellCb        *cell,
26707 RgSchCmnDlUe       *ueDl,
26708 U8                 cqi,
26709 U8                 cfi,
26710 U8                 cwIdx,
26711 U8                 noLyr
26712 )
26713 #else
26714 PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
26715 RgSchCellCb        *cell;
26716 RgSchCmnDlUe       *ueDl; 
26717 U8                 cqi;
26718 U8                 cfi;
26719 U8                 cwIdx;
26720 U8                 noLyr;
26721 #endif 
26722 #endif
26723 {
26724
26725    RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
26726    S32 iTbs = 0;
26727
26728    TRC2(rgSchCmnFetchItbs);
26729
26730 #ifdef LTE_TDD      
26731    /* Special Handling for Spl Sf when CFI is 3 as 
26732     * CFI in Spl Sf will be max 2 */
26733    if(subFrm->sfType == RG_SCH_SPL_SF_DATA) 
26734    {
26735       if((cellDl->currCfi == 3) || 
26736             ((cell->bwCfg.dlTotalBw <= 10) && (cellDl->currCfi == 1)))
26737       {    
26738          /* Use CFI 2 in this case */
26739          iTbs = (ueDl->laCb[cwIdx].deltaiTbs + 
26740                ((*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][2]))[cqi])* 100)/100;
26741
26742          RG_SCH_CHK_ITBS_RANGE(iTbs, RGSCH_NUM_ITBS - 1);
26743       }
26744       else
26745       {
26746          iTbs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1];
26747       }
26748       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26749    }   
26750    else /* CFI Changed. Update with new iTbs Reset the BLER*/
26751 #endif         
26752    {
26753       S32 tmpiTbs  = (*(RgSchCmnCqiToTbs *)(cellDl->cqiToTbsTbl[0][cfi]))[cqi];
26754       
26755       iTbs = (ueDl->laCb[cwIdx].deltaiTbs + tmpiTbs*100)/100;
26756
26757       RG_SCH_CHK_ITBS_RANGE(iTbs, tmpiTbs);     
26758
26759       iTbs = RGSCH_MIN(iTbs, cell->thresholds.maxDlItbs);
26760
26761       ueDl->mimoInfo.cwInfo[cwIdx].iTbs[noLyr - 1] = iTbs;
26762
26763       ueDl->lastCfi = cfi;
26764       ueDl->laCb[cwIdx].deltaiTbs = 0;
26765    }
26766
26767    RETVALUE(iTbs);
26768 } 
26769 \f
26770 /**
26771  * @brief This function determines the RBs and Bytes required for BO
26772  *        transmission for UEs configured with TM 1/2/6/7.
26773  *
26774  * @details
26775  *
26776  *     Function: rgSCHCmnDlAllocTxRb1Tb1Cw
26777  *     Purpose:  Allocate TB1 on CW1.
26778  *
26779  *               Reference Parameter effBo is filled with alloced bytes.
26780  *               Returns RFAILED if BO not satisfied at all.
26781  *
26782  *     Invoked by: rgSCHCmnDlAllocTxRbTM1/2/6/7
26783  *
26784  *  @param[in]  RgSchCellCb           *cell
26785  *  @param[in]  RgSchDlSf             *subFrm
26786  *  @param[in]  RgSchUeCb             *ue
26787  *  @param[in]  U32                   bo
26788  *  @param[out] U32                   *effBo
26789  *  @param[in]  RgSchDlHqProcCb       *proc
26790  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26791  *  @return  Void
26792  *
26793  **/
26794 #ifdef ANSI
26795 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw
26796 (
26797 RgSchCellCb                *cell,
26798 RgSchDlSf                  *subFrm,
26799 RgSchUeCb                  *ue,
26800 U32                        bo,
26801 U32                        *effBo,
26802 RgSchDlHqProcCb            *proc,
26803 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26804 )
26805 #else
26806 PRIVATE Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26807 RgSchCellCb                *cell;
26808 RgSchDlSf                  *subFrm;
26809 RgSchUeCb                  *ue;
26810 U32                        bo;
26811 U32                        *effBo;
26812 RgSchDlHqProcCb            *proc;
26813 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26814 #endif
26815 {
26816    RgSchDlRbAlloc   *allocInfo;
26817    S16              ret;
26818    U8               numRb;
26819    TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
26820
26821    ret = ROK;
26822    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26823 #ifdef RG_5GTF
26824    if (ue->ue5gtfCb.rank == 2)
26825    {
26826       allocInfo->dciFormat = TFU_DCI_FORMAT_B2;
26827    }
26828    else
26829    {
26830       allocInfo->dciFormat = TFU_DCI_FORMAT_B1;
26831    }
26832 #else
26833    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26834          allocInfo->raType);
26835 #endif
26836    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
26837          bo, &numRb, effBo);
26838    if (ret == RFAILED)
26839    {
26840       /* If allocation couldn't be made then return */
26841       RETVOID;
26842    }
26843    /* Adding UE to RbAllocInfo TX Lst */
26844    rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
26845    /* Fill UE alloc Info */
26846    allocInfo->rbsReq = numRb;
26847    allocInfo->dlSf   = subFrm;
26848 #ifdef RG_5GTF
26849    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26850 #endif
26851
26852    RETVOID;
26853 }
26854
26855 \f
26856 /**
26857  * @brief This function determines the RBs and Bytes required for BO
26858  *        retransmission for UEs configured with TM 1/2/6/7.
26859  *
26860  * @details
26861  *
26862  *     Function: rgSCHCmnDlAllocRetxRb1Tb1Cw
26863  *     Purpose:  Allocate TB1 on CW1.
26864  *
26865  *               Reference Parameter effBo is filled with alloced bytes.
26866  *               Returns RFAILED if BO not satisfied at all.
26867  *
26868  *     Invoked by: rgSCHCmnDlAllocRetxRbTM1/2/6/7
26869  *
26870  *  @param[in]  RgSchCellCb           *cell
26871  *  @param[in]  RgSchDlSf             *subFrm
26872  *  @param[in]  RgSchUeCb             *ue
26873  *  @param[in]  U32                   bo
26874  *  @param[out] U32                   *effBo
26875  *  @param[in]  RgSchDlHqProcCb       *proc
26876  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26877  *  @return  Void
26878  *
26879  **/
26880 #ifdef ANSI
26881 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw
26882 (
26883 RgSchCellCb                *cell,
26884 RgSchDlSf                  *subFrm,
26885 RgSchUeCb                  *ue,
26886 U32                        bo,
26887 U32                        *effBo,
26888 RgSchDlHqProcCb            *proc,
26889 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26890 )
26891 #else
26892 PRIVATE Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26893 RgSchCellCb                *cell;
26894 RgSchDlSf                  *subFrm;
26895 RgSchUeCb                  *ue;
26896 U32                        bo;
26897 U32                        *effBo;
26898 RgSchDlHqProcCb            *proc;
26899 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26900 #endif
26901 {
26902    RgSchDlRbAlloc   *allocInfo;
26903    S16              ret;
26904    U8               numRb;
26905    TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
26906
26907    ret = ROK;
26908    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
26909
26910 #ifndef RG_5GTF
26911    /* 5GTF: RETX DCI format same as TX */
26912    allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
26913       &allocInfo->raType);
26914 #endif
26915
26916    /* Get the Allocation in terms of RBs that are required for
26917     * this retx of TB1 */
26918    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
26919          1, &numRb, effBo);
26920    if (ret == RFAILED)
26921    {
26922       /* Allocation couldn't be made for Retx */
26923       /* Fix : syed If TxRetx allocation failed then add the UE along with the proc
26924        * to the nonSchdTxRetxUeLst and let spfc scheduler take care of it during
26925        * finalization. */        
26926       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
26927       RETVOID;
26928    }
26929    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
26930    /* Fill UE alloc Info */
26931    allocInfo->rbsReq = numRb;
26932    allocInfo->dlSf   = subFrm;
26933 #ifdef RG_5GTF
26934    allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
26935 #endif
26936
26937    RETVOID;
26938 }
26939
26940 \f
26941 /**
26942  * @brief This function determines the RBs and Bytes required for BO
26943  *        transmission for UEs configured with TM 2.
26944  *
26945  * @details
26946  *
26947  *     Function: rgSCHCmnDlAllocTxRbTM1
26948  *     Purpose:
26949  *
26950  *               Reference Parameter effBo is filled with alloced bytes.
26951  *               Returns RFAILED if BO not satisfied at all.
26952  *
26953  *     Invoked by: rgSCHCmnDlAllocTxRb
26954  *
26955  *  @param[in]  RgSchCellCb           *cell
26956  *  @param[in]  RgSchDlSf             *subFrm
26957  *  @param[in]  RgSchUeCb             *ue
26958  *  @param[in]  U32                   bo
26959  *  @param[out] U32                   *effBo
26960  *  @param[in]  RgSchDlHqProcCb       *proc
26961  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
26962  *  @return Void
26963  *
26964  **/
26965 #ifdef ANSI
26966 PRIVATE Void rgSCHCmnDlAllocTxRbTM1
26967 (
26968 RgSchCellCb                *cell,
26969 RgSchDlSf                  *subFrm,
26970 RgSchUeCb                  *ue,
26971 U32                        bo,
26972 U32                        *effBo,
26973 RgSchDlHqProcCb            *proc,
26974 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
26975 )
26976 #else
26977 PRIVATE Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
26978 RgSchCellCb                *cell;
26979 RgSchDlSf                  *subFrm;
26980 RgSchUeCb                  *ue;
26981 U32                        bo;
26982 U32                        *effBo;
26983 RgSchDlHqProcCb            *proc;
26984 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
26985 #endif
26986 {
26987    TRC2(rgSCHCmnDlAllocTxRbTM1);
26988    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
26989    RETVOID;
26990 }
26991
26992 \f
26993 /**
26994  * @brief This function determines the RBs and Bytes required for BO
26995  *        retransmission for UEs configured with TM 2.
26996  *
26997  * @details
26998  *
26999  *     Function: rgSCHCmnDlAllocRetxRbTM1
27000  *     Purpose:
27001  *
27002  *               Reference Parameter effBo is filled with alloced bytes.
27003  *               Returns RFAILED if BO not satisfied at all.
27004  *
27005  *     Invoked by: rgSCHCmnDlAllocRetxRb
27006  *
27007  *  @param[in]  RgSchCellCb           *cell
27008  *  @param[in]  RgSchDlSf             *subFrm
27009  *  @param[in]  RgSchUeCb             *ue
27010  *  @param[in]  U32                   bo
27011  *  @param[out] U32                   *effBo
27012  *  @param[in]  RgSchDlHqProcCb       *proc
27013  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27014  *  @return Void
27015  *
27016  **/
27017 #ifdef ANSI
27018 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1
27019 (
27020 RgSchCellCb                *cell,
27021 RgSchDlSf                  *subFrm,
27022 RgSchUeCb                  *ue,
27023 U32                        bo,
27024 U32                        *effBo,
27025 RgSchDlHqProcCb            *proc,
27026 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27027 )
27028 #else
27029 PRIVATE Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27030 RgSchCellCb                *cell;
27031 RgSchDlSf                  *subFrm;
27032 RgSchUeCb                  *ue;
27033 U32                        bo;
27034 U32                        *effBo;
27035 RgSchDlHqProcCb            *proc;
27036 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27037 #endif
27038 {
27039    TRC2(rgSCHCmnDlAllocRetxRbTM1);
27040    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27041    RETVOID;
27042 }
27043
27044 \f
27045 /**
27046  * @brief This function determines the RBs and Bytes required for BO
27047  *        transmission for UEs configured with TM 2.
27048  *
27049  * @details
27050  *
27051  *     Function: rgSCHCmnDlAllocTxRbTM2
27052  *     Purpose:
27053  *
27054  *               Reference Parameter effBo is filled with alloced bytes.
27055  *               Returns RFAILED if BO not satisfied at all.
27056  *
27057  *     Invoked by: rgSCHCmnDlAllocTxRb
27058  *
27059  *  @param[in]  RgSchCellCb           *cell
27060  *  @param[in]  RgSchDlSf             *subFrm
27061  *  @param[in]  RgSchUeCb             *ue
27062  *  @param[in]  U32                   bo
27063  *  @param[out] U32                   *effBo
27064  *  @param[in]  RgSchDlHqProcCb       *proc
27065  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27066  *  @return Void
27067  *
27068  **/
27069 #ifdef ANSI
27070 PRIVATE Void rgSCHCmnDlAllocTxRbTM2
27071 (
27072 RgSchCellCb                *cell,
27073 RgSchDlSf                  *subFrm,
27074 RgSchUeCb                  *ue,
27075 U32                        bo,
27076 U32                        *effBo,
27077 RgSchDlHqProcCb            *proc,
27078 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27079 )
27080 #else
27081 PRIVATE Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27082 RgSchCellCb                *cell;
27083 RgSchDlSf                  *subFrm;
27084 RgSchUeCb                  *ue;
27085 U32                        bo;
27086 U32                        *effBo;
27087 RgSchDlHqProcCb            *proc;
27088 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27089 #endif
27090 {
27091    TRC2(rgSCHCmnDlAllocTxRbTM2);
27092    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27093    RETVOID;
27094 }
27095
27096 \f
27097 /**
27098  * @brief This function determines the RBs and Bytes required for BO
27099  *        retransmission for UEs configured with TM 2.
27100  *
27101  * @details
27102  *
27103  *     Function: rgSCHCmnDlAllocRetxRbTM2
27104  *     Purpose:
27105  *
27106  *               Reference Parameter effBo is filled with alloced bytes.
27107  *               Returns RFAILED if BO not satisfied at all.
27108  *
27109  *     Invoked by: rgSCHCmnDlAllocRetxRb
27110  *
27111  *  @param[in]  RgSchCellCb           *cell
27112  *  @param[in]  RgSchDlSf             *subFrm
27113  *  @param[in]  RgSchUeCb             *ue
27114  *  @param[in]  U32                   bo
27115  *  @param[out] U32                   *effBo
27116  *  @param[in]  RgSchDlHqProcCb       *proc
27117  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27118  *  @return Void
27119  *
27120  **/
27121 #ifdef ANSI
27122 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2
27123 (
27124 RgSchCellCb                *cell,
27125 RgSchDlSf                  *subFrm,
27126 RgSchUeCb                  *ue,
27127 U32                        bo,
27128 U32                        *effBo,
27129 RgSchDlHqProcCb            *proc,
27130 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27131 )
27132 #else
27133 PRIVATE Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27134 RgSchCellCb                *cell;
27135 RgSchDlSf                  *subFrm;
27136 RgSchUeCb                  *ue;
27137 U32                        bo;
27138 U32                        *effBo;
27139 RgSchDlHqProcCb            *proc;
27140 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27141 #endif
27142 {
27143    TRC2(rgSCHCmnDlAllocRetxRbTM2);
27144    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
27145    RETVOID;
27146 }
27147
27148 \f
27149 /**
27150  * @brief This function determines the RBs and Bytes required for BO
27151  *        transmission for UEs configured with TM 3.
27152  *
27153  * @details
27154  *
27155  *     Function: rgSCHCmnDlAllocTxRbTM3
27156  *     Purpose:
27157  *
27158  *               Reference Parameter effBo is filled with alloced bytes.
27159  *               Returns RFAILED if BO not satisfied at all.
27160  *
27161  *     Invoked by: rgSCHCmnDlAllocTxRb
27162  *
27163  *  @param[in]  RgSchCellCb           *cell
27164  *  @param[in]  RgSchDlSf             *subFrm
27165  *  @param[in]  RgSchUeCb             *ue
27166  *  @param[in]  U32                   bo
27167  *  @param[out] U32                   *effBo
27168  *  @param[in]  RgSchDlHqProcCb       *proc
27169  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27170  *  @return Void
27171  *
27172  **/
27173 #ifdef ANSI
27174 PRIVATE Void rgSCHCmnDlAllocTxRbTM3
27175 (
27176 RgSchCellCb                *cell,
27177 RgSchDlSf                  *subFrm,
27178 RgSchUeCb                  *ue,
27179 U32                        bo,
27180 U32                        *effBo,
27181 RgSchDlHqProcCb            *proc,
27182 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27183 )
27184 #else
27185 PRIVATE Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27186 RgSchCellCb                *cell;
27187 RgSchDlSf                  *subFrm;
27188 RgSchUeCb                  *ue;
27189 U32                        bo;
27190 U32                        *effBo;
27191 RgSchDlHqProcCb            *proc;
27192 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27193 #endif
27194 {
27195
27196    TRC2(rgSCHCmnDlAllocTxRbTM3);
27197
27198    /* Both TBs free for TX allocation */
27199    rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
27200          proc, cellWdAllocInfo);
27201
27202    RETVOID;
27203 }
27204
27205 \f
27206 /**
27207  * @brief This function determines the RBs and Bytes required for BO
27208  *        retransmission for UEs configured with TM 3.
27209  *
27210  * @details
27211  *
27212  *     Function: rgSCHCmnDlAllocRetxRbTM3
27213  *     Purpose:
27214  *
27215  *               Reference Parameter effBo is filled with alloced bytes.
27216  *               Returns RFAILED if BO not satisfied at all.
27217  *
27218  *     Invoked by: rgSCHCmnDlAllocRetxRb
27219  *
27220  *  @param[in]  RgSchCellCb           *cell
27221  *  @param[in]  RgSchDlSf             *subFrm
27222  *  @param[in]  RgSchUeCb             *ue
27223  *  @param[in]  U32                   bo
27224  *  @param[out] U32                   *effBo
27225  *  @param[in]  RgSchDlHqProcCb       *proc
27226  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27227  *  @return Void
27228  *
27229  **/
27230 #ifdef ANSI
27231 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3
27232 (
27233 RgSchCellCb                *cell,
27234 RgSchDlSf                  *subFrm,
27235 RgSchUeCb                  *ue,
27236 U32                        bo,
27237 U32                        *effBo,
27238 RgSchDlHqProcCb            *proc,
27239 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27240 )
27241 #else
27242 PRIVATE Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27243 RgSchCellCb                *cell;
27244 RgSchDlSf                  *subFrm;
27245 RgSchUeCb                  *ue;
27246 U32                        bo;
27247 U32                        *effBo;
27248 RgSchDlHqProcCb            *proc;
27249 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27250 #endif
27251 {
27252
27253    TRC2(rgSCHCmnDlAllocRetxRbTM3);
27254
27255    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
27256          (proc->tbInfo[1].state == HQ_TB_NACKED))
27257    {
27258 #ifdef LAA_DBG_LOG
27259       printf ("RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
27260 #endif
27261       /* Both TBs require RETX allocation */
27262       rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo,\
27263             proc, cellWdAllocInfo);
27264    }
27265    else
27266    {
27267       /* One of the TBs need RETX allocation. Other TB may/maynot
27268        * be available for new TX allocation. */
27269       rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo,\
27270             proc, cellWdAllocInfo);
27271    }
27272
27273    RETVOID;
27274 }
27275
27276 \f
27277 /**
27278  * @brief This function performs the DCI format selection in case of
27279  *        Transmit Diversity scheme where there can be more
27280  *        than 1 option for DCI format selection.
27281  *
27282  * @details
27283  *
27284  *     Function: rgSCHCmnSlctPdcchFrmt
27285  *     Purpose:  1. If DLFS is enabled, then choose TM specific
27286  *                  DCI format for Transmit diversity. All the
27287  *                  TM Specific DCI Formats support Type0 and/or
27288  *                  Type1 resource allocation scheme. DLFS
27289  *                  supports only Type-0&1 Resource allocation.
27290  *               2. If DLFS is not enabled, select a DCI format
27291  *                  which is of smaller size. Since Non-DLFS
27292  *                  scheduler supports all Resource allocation
27293  *                  schemes, selection is based on efficiency.
27294  *
27295  *     Invoked by: DL UE Allocation by Common Scheduler.
27296  *
27297  *  @param[in]  RgSchCellCb      *cell
27298  *  @param[in]  RgSchUeCb        *ue
27299  *  @param[out] U8               *raType
27300  *  @return  TfuDciFormat
27301  *
27302  **/
27303 #ifdef ANSI
27304 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt
27305 (
27306 RgSchCellCb                *cell,
27307 RgSchUeCb                  *ue,
27308 U8                         *raType
27309 )
27310 #else
27311 PUBLIC TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
27312 RgSchCellCb                *cell;
27313 RgSchUeCb                  *ue;
27314 U8                         *raType;
27315 #endif
27316 {
27317    RgSchCmnCell   *cellSch = RG_SCH_CMN_GET_CELL(cell);
27318
27319    TRC2(rgSCHCmnSlctPdcchFrmt);
27320
27321    /* ccpu00140894- Selective DCI Format and RA type should be selected only 
27322     * after TX Mode transition is completed*/
27323    if ((cellSch->dl.isDlFreqSel) && (ue->txModeTransCmplt))
27324    {
27325       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciRAType;
27326       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].spfcDciFrmt);
27327    }
27328    else
27329    {
27330       *raType = rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciRAType;
27331       RETVALUE(rgSchCmnDciFrmtOptns[ue->mimoInfo.txMode-1].prfrdDciFrmt);
27332    }
27333 }
27334
27335 \f
27336 /**
27337  * @brief This function handles Retx allocation in case of TM3 UEs
27338  *        where both the TBs were NACKED previously.
27339  *
27340  * @details
27341  *
27342  *     Function: rgSCHCmnDlTM3RetxRetx
27343  *     Purpose:  If forceTD flag enabled
27344  *                  TD for TB1 on CW1.
27345  *               Else
27346  *                  DCI Frmt 2A and RA Type 0
27347  *                  RI layered SM of both TBs on 2 CWs
27348  *               Add UE to cell Alloc Info.
27349  *               Fill UE alloc Info.
27350  *
27351  *
27352  *               Successful allocation is indicated by non-zero effBo value.
27353  *
27354  *     Invoked by: rgSCHCmnDlAllocRbTM3
27355  *
27356  *  @param[in]  RgSchCellCb           *cell
27357  *  @param[in]  RgSchDlSf             *subFrm
27358  *  @param[in]  RgSchUeCb             *ue
27359  *  @param[in]  U32                   bo
27360  *  @param[out] U32                   *effBo
27361  *  @param[in]  RgSchDlHqProcCb       *proc
27362  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27363  *  @return  Void
27364  *
27365  **/
27366 #ifdef ANSI
27367 PRIVATE Void rgSCHCmnDlTM3RetxRetx
27368 (
27369 RgSchCellCb                *cell,
27370 RgSchDlSf                  *subFrm,
27371 RgSchUeCb                  *ue,
27372 U32                        bo,
27373 U32                        *effBo,
27374 RgSchDlHqProcCb            *proc,
27375 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27376 )
27377 #else
27378 PRIVATE Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27379 RgSchCellCb                *cell;
27380 RgSchDlSf                  *subFrm;
27381 RgSchUeCb                  *ue;
27382 U32                        bo;
27383 U32                        *effBo;
27384 RgSchDlHqProcCb            *proc;
27385 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27386 #endif
27387 {
27388    S16           ret;
27389    RgSchDlRbAlloc *allocInfo;
27390    U8            numRb;
27391    Bool          swpFlg;
27392    U8            precInfo;
27393    U8            noTxLyrs;
27394    U8            precInfoAntIdx;
27395
27396    TRC2(rgSCHCmnDlTM3RetxRetx);
27397
27398    ret = ROK;
27399    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27400    swpFlg = FALSE;
27401 /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27402    {
27403       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
27404       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27405
27406       ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27407             effBo);
27408       if (ret == RFAILED)
27409       {
27410          /* Allocation couldn't be made for Retx */
27411          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27412          RETVOID;
27413       }
27414       /* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
27415       noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27416 #ifdef FOUR_TX_ANTENNA
27417       /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1 should
27418        * have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27419       if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27420       {
27421          swpFlg = TRUE;
27422          proc->cwSwpEnabled = TRUE;
27423       }
27424 #endif
27425       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27426       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27427    }
27428
27429 #ifdef LTEMAC_SPS
27430    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27431 #endif
27432    {
27433       /* Adding UE to allocInfo RETX Lst */
27434       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27435    }
27436    /* Fill UE alloc Info scratch pad */
27437    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27438          precInfo, noTxLyrs, subFrm);
27439
27440    RETVOID;
27441 }
27442
27443 \f
27444 /**
27445  * @brief This function handles Retx allocation in case of TM4 UEs
27446  *        where both the TBs were NACKED previously.
27447  *
27448  * @details
27449  *
27450  *     Function: rgSCHCmnDlTM4RetxRetx
27451  *     Purpose:  If forceTD flag enabled
27452  *                  TD for TB1 on CW1.
27453  *               Else
27454  *                  DCI Frmt 2 and RA Type 0
27455  *                  If RI == 1
27456  *                     1 layer SM of TB1 on CW1.
27457  *                  Else
27458  *                     RI layered SM of both TBs on 2 CWs
27459  *               Add UE to cell Alloc Info.
27460  *               Fill UE alloc Info.
27461  *
27462  *
27463  *               Successful allocation is indicated by non-zero effBo value.
27464  *
27465  *     Invoked by: rgSCHCmnDlAllocRbTM4
27466  *
27467  *  @param[in]  RgSchCellCb           *cell
27468  *  @param[in]  RgSchDlSf             *subFrm
27469  *  @param[in]  RgSchUeCb             *ue
27470  *  @param[in]  U32                   bo
27471  *  @param[out] U32                   *effBo
27472  *  @param[in]  RgSchDlHqProcCb       *proc
27473  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
27474  *  @return  Void
27475  *
27476  **/
27477 #ifdef ANSI
27478 PRIVATE Void rgSCHCmnDlTM4RetxRetx
27479 (
27480 RgSchCellCb                *cell,
27481 RgSchDlSf                  *subFrm,
27482 RgSchUeCb                  *ue,
27483 U32                        bo,
27484 U32                        *effBo,
27485 RgSchDlHqProcCb            *proc,
27486 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
27487 )
27488 #else
27489 PRIVATE Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
27490 RgSchCellCb                *cell;
27491 RgSchDlSf                  *subFrm;
27492 RgSchUeCb                  *ue;
27493 U32                        bo;
27494 U32                        *effBo;
27495 RgSchDlHqProcCb            *proc;
27496 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
27497 #endif
27498 {
27499    S16            ret;
27500    RgSchDlRbAlloc *allocInfo;
27501    U8             numRb;
27502    Bool           swpFlg = FALSE;
27503    U8             precInfo;
27504 #ifdef FOUR_TX_ANTENNA
27505    U8             precInfoAntIdx;
27506 #endif
27507    U8             noTxLyrs;
27508
27509    TRC2(rgSCHCmnDlTM4RetxRetx);
27510
27511    ret = ROK;
27512    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
27513                        
27514    /* Irrespective of RI Schedule both CWs */
27515    allocInfo->dciFormat = TFU_DCI_FORMAT_2;
27516    allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
27517
27518    ret = rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc, &numRb, &swpFlg,\
27519          effBo);
27520    if (ret == RFAILED)
27521    {
27522       /* Allocation couldn't be made for Retx */
27523       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
27524       RETVOID;
27525    }
27526    noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
27527    precInfo = 0; 
27528 #ifdef FOUR_TX_ANTENNA
27529    /*Chandra: For 4X4 MIM RETX with noTxLyrs=3, CW0 should be 1-LyrTB and CW1
27530     * should have 2-LyrTB as per Table 6.3.3.2-1 of 36.211  */
27531    if(noTxLyrs == 3 &&  proc->tbInfo[0].numLyrs==2)
27532    {
27533       swpFlg = TRUE;
27534       proc->cwSwpEnabled = TRUE;
27535 }
27536 precInfoAntIdx = cell->numTxAntPorts/2 - 1;
27537 precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
27538 #endif
27539
27540 #ifdef LTEMAC_SPS
27541    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
27542 #endif
27543    {
27544       /* Adding UE to allocInfo RETX Lst */
27545       rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
27546    }
27547    /* Fill UE alloc Info scratch pad */
27548    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
27549          precInfo, noTxLyrs, subFrm);
27550
27551    RETVOID;
27552 }
27553
27554
27555 \f
27556 /**
27557  * @brief This function determines Transmission attributes
27558  *        incase of Spatial multiplexing for TX and RETX TBs.
27559  *
27560  * @details
27561  *
27562  *     Function: rgSCHCmnDlSMGetAttrForTxRetx
27563  *     Purpose:  1. Reached here for a TM3/4 UE's HqP whose one of the TBs is
27564  *                  NACKED and the other TB is either NACKED or WAITING.
27565  *               2. Select the NACKED TB for RETX allocation.
27566  *               3. Allocation preference for RETX TB by mapping it to a better
27567  *                  CW (better in terms of efficiency).
27568  *               4. Determine the state of the other TB.
27569  *                  Determine if swapFlag were to be set.
27570  *                  Swap flag would be set if Retx TB is cross
27571  *                  mapped to a CW.
27572  *               5. If UE has new data available for TX and if the other TB's state
27573  *                  is ACKED then set furtherScope as TRUE.
27574  *
27575  *     Invoked by: rgSCHCmnDlTM3[4]TxRetx
27576  *
27577  *  @param[in]  RgSchUeCb        *ue
27578  *  @param[in]  RgSchDlHqProcCb  *proc
27579  *  @param[out] RgSchDlHqTbCb    **retxTb
27580  *  @param[out] RgSchDlHqTbCb    **txTb
27581  *  @param[out] Bool             *frthrScp
27582  *  @param[out] Bool             *swpFlg
27583  *  @return  Void
27584  *
27585  **/
27586 #ifdef ANSI
27587 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx
27588 (
27589 RgSchUeCb                  *ue,
27590 RgSchDlHqProcCb            *proc,
27591 RgSchDlHqTbCb              **retxTb,
27592 RgSchDlHqTbCb              **txTb,
27593 Bool                       *frthrScp,
27594 Bool                       *swpFlg
27595 )
27596 #else
27597 PRIVATE Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
27598         swpFlg)
27599 RgSchUeCb                  *ue;
27600 RgSchDlHqProcCb            *proc;
27601 RgSchDlHqTbCb              **retxTb;
27602 RgSchDlHqTbCb              **txTb;
27603 Bool                       *frthrScp;
27604 Bool                       *swpFlg;
27605 #endif
27606 {
27607    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
27608    RgSchDlRbAlloc  *allocInfo;
27609
27610    TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
27611
27612    if (proc->tbInfo[0].state == HQ_TB_NACKED)
27613    {
27614       *retxTb = &proc->tbInfo[0];
27615       *txTb = &proc->tbInfo[1];
27616       /* TENB_BRDCM_TM4- Currently disabling swapflag for TM3/TM4, since 
27617        * HqFeedback processing does not consider a swapped hq feedback */
27618       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 1))
27619       {
27620          *swpFlg = TRUE;
27621          proc->cwSwpEnabled = TRUE;
27622       }
27623       if (proc->tbInfo[1].state == HQ_TB_ACKED)
27624       {
27625          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27626          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27627       }
27628    }
27629    else
27630    {
27631       *retxTb = &proc->tbInfo[1];
27632       *txTb = &proc->tbInfo[0];
27633       /* TENB_BRDCM_TM4 - Currently disabling swapflag for TM3/TM4, since 
27634        * HqFeedback processing does not consider a swapped hq feedback */
27635       if ((ue->mimoInfo.txMode == RGR_UE_TM_4) && (ueDl->mimoInfo.btrCwIdx == 0))
27636       {
27637          *swpFlg = TRUE;
27638          proc->cwSwpEnabled = TRUE;
27639       }
27640       if (proc->tbInfo[0].state == HQ_TB_ACKED)
27641       {
27642          allocInfo =  RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, proc->hqE->cell);
27643          *frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
27644       }
27645    }
27646    RETVOID;
27647 }
27648
27649 \f
27650 /**
27651  * @brief Determine Precoding information for TM3 2 TX Antenna.
27652  *
27653  * @details
27654  *
27655  *     Function: rgSCHCmnDlTM3PrecInf2
27656  *     Purpose:
27657  *
27658  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27659  *
27660  *  @param[in]  RgSchUeCb        *ue
27661  *  @param[in]  U8               numTxLyrs
27662  *  @param[in]  Bool             bothCwEnbld
27663  *  @return  U8
27664  *
27665  **/
27666 #ifdef ANSI
27667 PRIVATE U8 rgSCHCmnDlTM3PrecInf2
27668 (
27669 RgSchCellCb                *cell,
27670 RgSchUeCb                  *ue,
27671 U8                         numTxLyrs,
27672 Bool                       bothCwEnbld
27673 )
27674 #else
27675 PRIVATE U8 rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
27676 RgSchCellCb                *cell;
27677 RgSchUeCb                  *ue;
27678 U8                         numTxLyrs;
27679 Bool                       bothCwEnbld;
27680 #endif
27681 {
27682    TRC2(rgSCHCmnDlTM3PrecInf2);
27683
27684    RETVALUE(0);
27685 }
27686
27687 \f
27688 /**
27689  * @brief Determine Precoding information for TM4 2 TX Antenna.
27690  *
27691  * @details
27692  *
27693  *     Function: rgSCHCmnDlTM4PrecInf2
27694  *     Purpose:  To determine a logic of deriving precoding index
27695  *               information from 36.212 table 5.3.3.1.5-4
27696  *
27697  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27698  *
27699  *  @param[in]  RgSchUeCb        *ue
27700  *  @param[in]  U8               numTxLyrs
27701  *  @param[in]  Bool             bothCwEnbld
27702  *  @return  U8
27703  *
27704  **/
27705 #ifdef ANSI
27706 PRIVATE U8 rgSCHCmnDlTM4PrecInf2
27707 (
27708 RgSchCellCb                *cell,
27709 RgSchUeCb                  *ue,
27710 U8                         numTxLyrs,
27711 Bool                       bothCwEnbld
27712 )
27713 #else
27714 PRIVATE U8 rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
27715 RgSchCellCb                *cell;
27716 RgSchUeCb                  *ue;
27717 U8                         numTxLyrs;
27718 Bool                       bothCwEnbld;
27719 #endif
27720 {
27721    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27722    U8            precIdx;
27723
27724    TRC2(rgSCHCmnDlTM4PrecInf2);
27725
27726    if (ueDl->mimoInfo.ri == numTxLyrs)
27727    {
27728       if (ueDl->mimoInfo.ri == 2)
27729       {
27730          /* PrecInfo corresponding to 2 CW
27731            Transmission */
27732          if (ue->mimoInfo.puschFdbkVld)
27733          {
27734             precIdx = 2;
27735          }
27736          else 
27737          {
27738             precIdx = ueDl->mimoInfo.pmi - 1;
27739          }
27740       }
27741       else
27742       {
27743          /* PrecInfo corresponding to 1 CW
27744           * Transmission */
27745          if (ue->mimoInfo.puschFdbkVld)
27746          {
27747             precIdx =  5;
27748          }
27749          else
27750          {
27751             precIdx =  ueDl->mimoInfo.pmi + 1;
27752          }
27753       }
27754    }
27755    else if (ueDl->mimoInfo.ri > numTxLyrs)
27756    {
27757       /* In case of choosing among the columns of a
27758        * precoding matrix, choose the column corresponding
27759        * to the MAX-CQI */
27760       if (ue->mimoInfo.puschFdbkVld)
27761       {
27762          precIdx = 5;
27763       }
27764       else
27765       {
27766          precIdx = (ueDl->mimoInfo.pmi- 1)* 2  + 1;
27767       }
27768    }
27769    else /* if RI < numTxLyrs */
27770    {
27771       precIdx = (ueDl->mimoInfo.pmi < 2)? 0:1;
27772    }
27773    RETVALUE(precIdx);
27774 }
27775
27776 \f
27777 /**
27778  * @brief Determine Precoding information for TM3 4 TX Antenna.
27779  *
27780  * @details
27781  *
27782  *     Function: rgSCHCmnDlTM3PrecInf4
27783  *     Purpose:  To determine a logic of deriving precoding index
27784  *               information from 36.212 table 5.3.3.1.5A-2
27785  *
27786  *     Invoked by: rgSCHCmnDlGetAttrForTM3
27787  *
27788  *  @param[in]  RgSchUeCb        *ue
27789  *  @param[in]  U8               numTxLyrs
27790  *  @param[in]  Bool             bothCwEnbld
27791  *  @return  U8
27792  *
27793  **/
27794 #ifdef ANSI
27795 PRIVATE U8 rgSCHCmnDlTM3PrecInf4
27796 (
27797 RgSchCellCb                *cell,
27798 RgSchUeCb                  *ue,
27799 U8                         numTxLyrs,
27800 Bool                       bothCwEnbld
27801 )
27802 #else
27803 PRIVATE U8 rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
27804 RgSchCellCb                *cell;
27805 RgSchUeCb                  *ue;
27806 U8                         numTxLyrs;
27807 Bool                       bothCwEnbld;
27808 #endif
27809 {
27810    U8            precIdx;
27811
27812    TRC2(rgSCHCmnDlTM3PrecInf4);
27813
27814    if (bothCwEnbld)
27815    {
27816       precIdx = numTxLyrs - 2;
27817    }
27818    else /* one 1 CW transmission */
27819    {
27820       precIdx = 1;
27821    }
27822    RETVALUE(precIdx);
27823 }
27824
27825 \f
27826 /**
27827  * @brief Determine Precoding information for TM4 4 TX Antenna.
27828  *
27829  * @details
27830  *
27831  *     Function: rgSCHCmnDlTM4PrecInf4
27832  *     Purpose:  To determine a logic of deriving precoding index
27833  *               information from 36.212 table 5.3.3.1.5-5
27834  *
27835  *     Invoked by: rgSCHCmnDlGetAttrForTM4
27836  *
27837  *  @param[in]  RgSchUeCb        *ue
27838  *  @param[in]  U8               numTxLyrs
27839  *  @param[in]  Bool             bothCwEnbld
27840  *  @return  U8
27841  *
27842  **/
27843 #ifdef ANSI
27844 PRIVATE U8 rgSCHCmnDlTM4PrecInf4
27845 (
27846 RgSchCellCb                *cell,
27847 RgSchUeCb                  *ue,
27848 U8                         numTxLyrs,
27849 Bool                       bothCwEnbld
27850 )
27851 #else
27852 PRIVATE U8 rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
27853 RgSchCellCb                *cell;
27854 RgSchUeCb                  *ue;
27855 U8                         numTxLyrs;
27856 Bool                       bothCwEnbld;
27857 #endif
27858 {
27859    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27860    U8            precInfoBaseIdx, precIdx;
27861
27862    TRC2(rgSCHCmnDlTM4PrecInf4);
27863
27864    precInfoBaseIdx  = (ue->mimoInfo.puschFdbkVld)? (16):
27865       (ueDl->mimoInfo.pmi);
27866    if (bothCwEnbld)
27867    {
27868       precIdx = precInfoBaseIdx + (numTxLyrs-2)*17;
27869    }
27870    else /* one 1 CW transmission */
27871    {
27872       precInfoBaseIdx += 1;
27873       precIdx = precInfoBaseIdx + (numTxLyrs-1)*17;
27874    }
27875    RETVALUE(precIdx);
27876 }
27877
27878 \f
27879 /**
27880  * @brief This function determines Transmission attributes
27881  *        incase of TM3 scheduling.
27882  *
27883  * @details
27884  *
27885  *     Function: rgSCHCmnDlGetAttrForTM3
27886  *     Purpose:  Determine retx TB and tx TB based on TB states.
27887  *               If forceTD enabled
27888  *                  perform only retx TB allocation.
27889  *                  If retxTB == TB2 then DCI Frmt = 2A, RA Type = 0.
27890  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
27891  *               If RI == 1
27892  *                  perform retxTB allocation on CW1.
27893  *               Else if RI > 1
27894  *                  Determine further Scope and Swap Flag attributes
27895  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
27896  *                  If no further scope for new TX allocation
27897  *                     Allocate only retx TB using 2 layers if
27898  *                     this TB was previously transmitted using 2 layers AND
27899  *                     number of Tx antenna ports == 4.
27900  *                     otherwise do single layer precoding.
27901  *
27902  *     Invoked by: rgSCHCmnDlTM3TxRetx
27903  *
27904  *  @param[in]  RgSchUeCb        *ue
27905  *  @param[in]  RgSchDlHqProcCb  *proc
27906  *  @param[out] U8               *numTxLyrs
27907  *  @param[out] Bool             *isTraDiv
27908  *  @param[out] U8               *prcdngInf
27909  *  @param[out] U8               *raType
27910  *  @return  Void
27911  *
27912  **/
27913 #ifdef ANSI
27914 PRIVATE Void rgSCHCmnDlGetAttrForTM3
27915 (
27916 RgSchCellCb                *cell,
27917 RgSchUeCb                  *ue,
27918 RgSchDlHqProcCb            *proc,
27919 U8                         *numTxLyrs,
27920 TfuDciFormat               *dciFrmt,
27921 U8                         *prcdngInf,
27922 RgSchDlHqTbCb              **retxTb,
27923 RgSchDlHqTbCb              **txTb,
27924 Bool                       *frthrScp,
27925 Bool                       *swpFlg,
27926 U8                         *raType
27927 )
27928 #else
27929 PRIVATE Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
27930         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
27931 RgSchCellCb                *cell;
27932 RgSchUeCb                  *ue;
27933 RgSchDlHqProcCb            *proc;
27934 U8                         *numTxLyrs;
27935 TfuDciFormat               *dciFrmt;
27936 U8                         *prcdngInf;
27937 RgSchDlHqTbCb              **retxTb;
27938 RgSchDlHqTbCb              **txTb;
27939 Bool                       *frthrScp;
27940 Bool                       *swpFlg;
27941 U8                         *raType;
27942 #endif
27943 {
27944    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
27945    U8            precInfoAntIdx;
27946
27947    TRC2(rgSCHCmnDlGetAttrForTM3);
27948
27949    /* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with 
27950       HQP */
27951    /* Integration_fix: SPS Proc shall always have only one Cw */
27952 #ifdef LTEMAC_SPS
27953    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
27954          (ueDl->mimoInfo.forceTD)) 
27955 #ifdef LTE_ADV
27956      ||(TRUE == rgSCHLaaSCellEnabled(cell))
27957 #endif
27958       )
27959 #else
27960    if ((ueDl->mimoInfo.forceTD) 
27961 #ifdef LTE_ADV
27962        || (TRUE == rgSCHLaaSCellEnabled(cell))
27963 #endif
27964       )
27965 #endif
27966    {
27967       /* Transmit Diversity. Format based on dlfsEnabled
27968        * No further scope */
27969       if (proc->tbInfo[0].state == HQ_TB_NACKED)
27970       {
27971          *retxTb = &proc->tbInfo[0];
27972          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
27973       }
27974       else
27975       {
27976          *retxTb = &proc->tbInfo[1];
27977          *dciFrmt = TFU_DCI_FORMAT_2A;
27978          *raType = RG_SCH_CMN_RA_TYPE0;
27979       }
27980       *numTxLyrs = 1;
27981       *frthrScp = FALSE;
27982       *prcdngInf = 0;
27983       RETVOID;
27984    }
27985
27986    /* Determine the 2 TB transmission attributes */
27987    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
27988          frthrScp, swpFlg);
27989    if (*frthrScp)
27990    {
27991       /* Prefer allocation of RETX TB over 2 layers rather than combining
27992        * it with a new TX. */
27993       if ((ueDl->mimoInfo.ri == 2)
27994             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
27995       {
27996          /* Allocate TB on CW1, using 2 Lyrs,
27997           * Format 2, precoding accordingly */
27998          *numTxLyrs = 2;
27999          *frthrScp = FALSE;
28000       }
28001       else
28002       {
28003          *numTxLyrs=  ((*retxTb)->numLyrs + ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)].noLyr);
28004
28005          if((*retxTb)->tbIdx == 0 && ((*retxTb)->numLyrs == 2 ) && *numTxLyrs ==3)
28006          {
28007             *swpFlg = TRUE;
28008             proc->cwSwpEnabled = TRUE;
28009          }
28010          else if((*retxTb)->tbIdx == 1 && ((*retxTb)->numLyrs == 1) && *numTxLyrs ==3)
28011          {
28012             *swpFlg = TRUE;
28013             proc->cwSwpEnabled = TRUE;
28014          }
28015       }
28016
28017       precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28018       *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])\
28019                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28020       *dciFrmt = TFU_DCI_FORMAT_2A;
28021       *raType = RG_SCH_CMN_RA_TYPE0;
28022    }
28023    else /* frthrScp == FALSE */
28024    {
28025       if (cell->numTxAntPorts == 2)
28026       {
28027          /*  Transmit Diversity  */
28028          *numTxLyrs = 1;
28029          if ((*retxTb)->tbIdx == 0)
28030          {
28031             *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28032          }
28033          else
28034          {
28035             /* If retxTB is TB2 then use format 2A */
28036             *dciFrmt = TFU_DCI_FORMAT_2A;
28037             *raType = RG_SCH_CMN_RA_TYPE0;
28038          }
28039          *prcdngInf = 0;
28040          RETVOID;
28041       }
28042       else /* NumAntPorts == 4 */
28043       {
28044          if ((*retxTb)->numLyrs == 2)
28045          {
28046             /* Allocate TB on CW1, using 2 Lyrs,
28047              * Format 2A, precoding accordingly */
28048             *numTxLyrs = 2;
28049             *dciFrmt = TFU_DCI_FORMAT_2A;
28050             *raType = RG_SCH_CMN_RA_TYPE0;
28051             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28052             *prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, *numTxLyrs, *frthrScp);
28053             RETVOID;
28054          }
28055          else
28056          {
28057             /*  Transmit Diversity  */
28058             *numTxLyrs = 1;
28059             if ((*retxTb)->tbIdx == 0)
28060             {
28061                *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28062             }
28063             else
28064             {
28065                /* If retxTB is TB2 then use format 2A */
28066                *dciFrmt = TFU_DCI_FORMAT_2A;
28067                *raType = RG_SCH_CMN_RA_TYPE0;
28068             }
28069             *prcdngInf = 0;
28070             RETVOID;
28071          }
28072       }
28073    }
28074
28075    RETVOID;
28076 }
28077
28078
28079 \f
28080 /**
28081  * @brief This function determines Transmission attributes
28082  *        incase of TM4 scheduling.
28083  *
28084  * @details
28085  *
28086  *     Function: rgSCHCmnDlGetAttrForTM4
28087  *     Purpose:  Determine retx TB and tx TB based on TB states.
28088  *               If forceTD enabled
28089  *                  perform only retx TB allocation.
28090  *                  If retxTB == TB2 then DCI Frmt = 2, RA Type = 0.
28091  *                  Else DCI Frmt and RA Type based on cell->isDlfsEnbld
28092  *               If RI == 1
28093  *                  perform retxTB allocation on CW1.
28094  *               Else if RI > 1
28095  *                  Determine further Scope and Swap Flag attributes
28096  *                  assuming a 2 CW transmission of RetxTB and new Tx TB.
28097  *                  If no further scope for new TX allocation
28098  *                     Allocate only retx TB using 2 layers if
28099  *                     this TB was previously transmitted using 2 layers AND
28100  *                     number of Tx antenna ports == 4.
28101  *                     otherwise do single layer precoding.
28102  *
28103  *     Invoked by: rgSCHCmnDlTM4TxRetx
28104  *
28105  *  @param[in]  RgSchUeCb        *ue
28106  *  @param[in]  RgSchDlHqProcCb  *proc
28107  *  @param[out] U8               *numTxLyrs
28108  *  @param[out] Bool             *isTraDiv
28109  *  @param[out] U8               *prcdngInf
28110  *  @param[out] U8               *raType
28111  *  @return  Void
28112  *
28113  **/
28114 #ifdef ANSI
28115 PRIVATE Void rgSCHCmnDlGetAttrForTM4
28116 (
28117 RgSchCellCb                *cell,
28118 RgSchUeCb                  *ue,
28119 RgSchDlHqProcCb            *proc,
28120 U8                         *numTxLyrs,
28121 TfuDciFormat               *dciFrmt,
28122 U8                         *prcdngInf,
28123 RgSchDlHqTbCb              **retxTb,
28124 RgSchDlHqTbCb              **txTb,
28125 Bool                       *frthrScp,
28126 Bool                       *swpFlg,
28127 U8                         *raType
28128 )
28129 #else
28130 PRIVATE Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
28131         prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
28132 RgSchCellCb                *cell;
28133 RgSchUeCb                  *ue;
28134 RgSchDlHqProcCb            *proc;
28135 U8                         *numTxLyrs;
28136 TfuDciFormat               *dciFrmt;
28137 U8                         *prcdngInf;
28138 RgSchDlHqTbCb              **retxTb;
28139 RgSchDlHqTbCb              **txTb;
28140 Bool                       *frthrScp;
28141 Bool                       *swpFlg;
28142 U8                         *raType;
28143 #endif
28144 {
28145    RgSchCmnDlUe  *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28146    U8 precInfoAntIdx;
28147
28148    TRC2(rgSCHCmnDlGetAttrForTM4);
28149
28150    *frthrScp = FALSE;
28151    /* Integration_fix: SPS Proc shall always have only one Cw */
28152 #ifdef LTEMAC_SPS
28153    if (((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28154          (ueDl->mimoInfo.forceTD)) 
28155 #ifdef LTE_ADV
28156      ||(TRUE == rgSCHLaaSCellEnabled(cell))
28157 #endif
28158       )
28159 #else
28160    if ((ueDl->mimoInfo.forceTD) 
28161 #ifdef LTE_ADV
28162        || (TRUE == rgSCHLaaSCellEnabled(cell))
28163 #endif
28164       )
28165 #endif
28166    {
28167       /* Transmit Diversity. Format based on dlfsEnabled
28168        * No further scope */
28169       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28170       {
28171          *retxTb = &proc->tbInfo[0];
28172          *dciFrmt = rgSCHCmnSlctPdcchFrmt(cell, ue, raType);
28173       }
28174       else
28175       {
28176          *retxTb = &proc->tbInfo[1];
28177          *dciFrmt = TFU_DCI_FORMAT_2;
28178          *raType = RG_SCH_CMN_RA_TYPE0;
28179       }
28180       *numTxLyrs = 1;
28181       *frthrScp = FALSE;
28182       *prcdngInf = 0;
28183       RETVOID;
28184    }
28185
28186    if (ueDl->mimoInfo.ri == 1)
28187    {
28188       /* single layer precoding. Format 2.
28189        * No further scope */
28190       if (proc->tbInfo[0].state == HQ_TB_NACKED)
28191       {
28192          *retxTb = &proc->tbInfo[0];
28193       }
28194       else
28195       {
28196          *retxTb = &proc->tbInfo[1];
28197       }
28198       *numTxLyrs = 1;
28199       *dciFrmt = TFU_DCI_FORMAT_2;
28200       *raType = RG_SCH_CMN_RA_TYPE0;
28201       *frthrScp = FALSE;
28202       *prcdngInf = 0; /*When RI= 1*/
28203       RETVOID;
28204    }
28205
28206    /* Determine the 2 TB transmission attributes */
28207    rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, \
28208          frthrScp, swpFlg);
28209    *dciFrmt = TFU_DCI_FORMAT_2;
28210    *raType = RG_SCH_CMN_RA_TYPE0;
28211    if (*frthrScp)
28212    {
28213       /* Prefer allocation of RETX TB over 2 layers rather than combining
28214        * it with a new TX. */
28215       if ((ueDl->mimoInfo.ri == 2)
28216             && ((*retxTb)->numLyrs == 2) && (cell->numTxAntPorts == 4))
28217       {
28218          /* Allocate TB on CW1, using 2 Lyrs,
28219           * Format 2, precoding accordingly */
28220          *numTxLyrs = 2;
28221          *frthrScp = FALSE;
28222       }
28223       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28224       *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])
28225                    (cell, ue, ueDl->mimoInfo.ri, *frthrScp);
28226    }
28227    else /* frthrScp == FALSE */
28228    {
28229       if (cell->numTxAntPorts == 2)
28230       {
28231          /* single layer precoding. Format 2. */
28232          *numTxLyrs = 1;
28233          *prcdngInf = (getPrecInfoFunc[1][cell->numTxAntPorts/2 - 1])\
28234                       (cell, ue, *numTxLyrs, *frthrScp);
28235          RETVOID;
28236       }
28237       else /* NumAntPorts == 4 */
28238       {
28239          if ((*retxTb)->numLyrs == 2)
28240          {
28241             /* Allocate TB on CW1, using 2 Lyrs,
28242              * Format 2, precoding accordingly */
28243             *numTxLyrs = 2;
28244             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28245             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28246                          (cell, ue, *numTxLyrs, *frthrScp);
28247             RETVOID;
28248          }
28249          else
28250          {
28251             /* Allocate TB with 1 lyr precoding,
28252              * Format 2, precoding info accordingly */
28253             *numTxLyrs = 1;
28254             precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28255             *prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
28256                          (cell, ue, *numTxLyrs, *frthrScp);
28257             RETVOID;
28258          }
28259       }
28260    }
28261
28262    RETVOID;
28263 }
28264
28265 \f
28266 /**
28267  * @brief This function handles Retx allocation in case of TM3 UEs
28268  *        where previously one of the TBs was NACKED and the other
28269  *        TB is either ACKED/WAITING.
28270  *
28271  * @details
28272  *
28273  *     Function: rgSCHCmnDlTM3TxRetx
28274  *     Purpose:  Determine the TX attributes for TM3 TxRetx Allocation.
28275  *               If futher Scope for New Tx Allocation on other TB
28276  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28277  *                  Add UE to cell wide RetxTx List.
28278  *               Else
28279  *                  Perform only RETX alloc'n on CW1.
28280  *                  Add UE to cell wide Retx List.
28281  *
28282  *               effBo is set to a non-zero value if allocation is
28283  *               successful.
28284  *
28285  *     Invoked by: rgSCHCmnDlAllocRbTM3
28286  *
28287  *  @param[in]  RgSchCellCb           *cell
28288  *  @param[in]  RgSchDlSf             *subFrm
28289  *  @param[in]  RgSchUeCb             *ue
28290  *  @param[in]  U32                   bo
28291  *  @param[out] U32                   *effBo
28292  *  @param[in]  RgSchDlHqProcCb       *proc
28293  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28294  *  @return  Void
28295  *
28296  **/
28297 #ifdef ANSI
28298 PRIVATE Void rgSCHCmnDlTM3TxRetx
28299 (
28300 RgSchCellCb                *cell,
28301 RgSchDlSf                  *subFrm,
28302 RgSchUeCb                  *ue,
28303 U32                        bo,
28304 U32                        *effBo,
28305 RgSchDlHqProcCb            *proc,
28306 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28307 )
28308 #else
28309 PRIVATE Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28310 RgSchCellCb                *cell;
28311 RgSchDlSf                  *subFrm;
28312 RgSchUeCb                  *ue;
28313 U32                        bo;
28314 U32                        *effBo;
28315 RgSchDlHqProcCb            *proc;
28316 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28317 #endif
28318 {
28319    S16              ret;
28320    RgSchDlRbAlloc   *allocInfo;
28321    U8               numRb;
28322    RgSchDlHqTbCb    *retxTb, *txTb;
28323    Bool             frthrScp;
28324    Bool             swpFlg;
28325    U8               prcdngInf;
28326    U8               numTxLyrs;
28327
28328    TRC2(rgSCHCmnDlTM3TxRetx);
28329    frthrScp = FALSE;
28330
28331    ret = ROK;
28332    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28333    swpFlg = FALSE;
28334
28335    /* Determine the transmission attributes */
28336    rgSCHCmnDlGetAttrForTM3(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28337          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28338          &allocInfo->raType);
28339
28340    if (frthrScp)
28341    {
28342 #ifdef LAA_DBG_LOG
28343       printf ("TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
28344 #endif
28345       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28346             &numRb, effBo);
28347       if (ret == RFAILED)
28348       {
28349          /* Allocation couldn't be made for Retx */
28350          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28351          RETVOID;
28352       }
28353       /* Adding UE to RbAllocInfo RETX-TX Lst */
28354       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28355    }
28356    else
28357    {
28358       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28359             numTxLyrs, &numRb, effBo);
28360       if (ret == RFAILED)
28361       {
28362          /* Allocation couldn't be made for Retx */
28363          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28364          RETVOID;
28365       }
28366 #ifdef LTEMAC_SPS
28367       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28368 #endif
28369       {
28370          /* Adding UE to allocInfo RETX Lst */
28371          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28372       }
28373    }
28374    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28375          prcdngInf, numTxLyrs, subFrm);
28376
28377    RETVOID;
28378 }
28379
28380 \f
28381 /**
28382  * @brief This function handles Retx allocation in case of TM4 UEs
28383  *        where previously one of the TBs was NACKED and the other
28384  *        TB is either ACKED/WAITING.
28385  *
28386  * @details
28387  *
28388  *     Function: rgSCHCmnDlTM4TxRetx
28389  *     Purpose:  Determine the TX attributes for TM4 TxRetx Allocation.
28390  *               If futher Scope for New Tx Allocation on other TB
28391  *                  Perform RETX alloc'n on 1 CW and TX alloc'n on other.
28392  *                  Add UE to cell wide RetxTx List.
28393  *               Else
28394  *                  Perform only RETX alloc'n on CW1.
28395  *                  Add UE to cell wide Retx List.
28396  *
28397  *               effBo is set to a non-zero value if allocation is
28398  *               successful.
28399  *
28400  *     Invoked by: rgSCHCmnDlAllocRbTM4
28401  *
28402  *  @param[in]  RgSchCellCb           *cell
28403  *  @param[in]  RgSchDlSf             *subFrm
28404  *  @param[in]  RgSchUeCb             *ue
28405  *  @param[in]  U32                   bo
28406  *  @param[out] U32                   *effBo
28407  *  @param[in]  RgSchDlHqProcCb       *proc
28408  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28409  *  @return  Void
28410  *
28411  **/
28412 #ifdef ANSI
28413 PRIVATE Void rgSCHCmnDlTM4TxRetx
28414 (
28415 RgSchCellCb                *cell,
28416 RgSchDlSf                  *subFrm,
28417 RgSchUeCb                  *ue,
28418 U32                        bo,
28419 U32                        *effBo,
28420 RgSchDlHqProcCb            *proc,
28421 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28422 )
28423 #else
28424 PRIVATE Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28425 RgSchCellCb                *cell;
28426 RgSchDlSf                  *subFrm;
28427 RgSchUeCb                  *ue;
28428 U32                        bo;
28429 U32                        *effBo;
28430 RgSchDlHqProcCb            *proc;
28431 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28432 #endif
28433 {
28434    S16              ret;
28435    RgSchDlRbAlloc   *allocInfo;
28436    U8               numRb;
28437    RgSchDlHqTbCb    *retxTb, *txTb;
28438    Bool             frthrScp;
28439    Bool             swpFlg;
28440    U8               prcdngInf;
28441    U8               numTxLyrs;
28442
28443    TRC2(rgSCHCmnDlTM4TxRetx);
28444
28445    ret = ROK;
28446    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28447    swpFlg = FALSE;
28448
28449    /* Determine the transmission attributes */
28450    rgSCHCmnDlGetAttrForTM4(cell, ue, proc, &numTxLyrs, &allocInfo->dciFormat,\
28451          &prcdngInf, &retxTb, &txTb, &frthrScp, &swpFlg,\
28452          &allocInfo->raType);
28453
28454    if (frthrScp)
28455    {
28456       ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
28457             &numRb, effBo);
28458       if (ret == RFAILED)
28459       {
28460          /* Fix : syed If TxRetx allocation failed then add the UE along 
28461           * with the proc to the nonSchdTxRetxUeLst and let spfc scheduler
28462           *  take care of it during finalization. */       
28463          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28464          RETVOID;
28465       }
28466       /* Adding UE to RbAllocInfo RETX-TX Lst */
28467       rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
28468    }
28469    else
28470    {
28471       ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, retxTb,
28472             numTxLyrs, &numRb, effBo);
28473       if (ret == RFAILED)
28474       {
28475          /* Allocation couldn't be made for Retx */
28476          rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
28477          RETVOID;
28478       }
28479 #ifdef LTEMAC_SPS
28480       if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28481 #endif
28482       {
28483          /* Adding UE to allocInfo RETX Lst */
28484          rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
28485       }
28486    }
28487    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
28488          prcdngInf, numTxLyrs, subFrm)
28489
28490       RETVOID;
28491 }
28492
28493 \f
28494 /**
28495  * @brief This function handles Retx allocation in case of TM4 UEs
28496  *        where previously both the TBs were ACKED and ACKED
28497  *        respectively.
28498  *
28499  * @details
28500  *
28501  *     Function: rgSCHCmnDlTM3TxTx
28502  *     Purpose:  Reached here for a TM3 UE's HqP's fresh allocation
28503  *                  where both the TBs are free for TX scheduling.
28504  *               If forceTD flag is set
28505  *                  perform TD on CW1 with TB1.
28506  *                  precInfo = 0
28507  *               else
28508  *                  DCI Format = 2A.
28509  *                  RA Type = Type0.
28510  *                  RI layered precoding 2 TB on 2 CW.
28511  *                  Set precoding info.
28512  *               Add UE to cellAllocInfo.
28513  *               Fill ueAllocInfo.
28514  *
28515  *              effBo is set to a non-zero value if allocation is
28516  *              successful.
28517  *
28518  *     Invoked by: rgSCHCmnDlAllocRbTM3
28519  *
28520  *  @param[in]  RgSchCellCb           *cell
28521  *  @param[in]  RgSchDlSf             *subFrm
28522  *  @param[in]  RgSchUeCb             *ue
28523  *  @param[in]  U32                   bo
28524  *  @param[out] U32                   *effBo
28525  *  @param[in]  RgSchDlHqProcCb       *proc
28526  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28527  *  @return  Void
28528  *
28529  **/
28530 #ifdef ANSI
28531 PRIVATE Void rgSCHCmnDlTM3TxTx
28532 (
28533 RgSchCellCb                *cell,
28534 RgSchDlSf                  *subFrm,
28535 RgSchUeCb                  *ue,
28536 U32                        bo,
28537 U32                        *effBo,
28538 RgSchDlHqProcCb            *proc,
28539 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28540 )
28541 #else
28542 PRIVATE Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28543 RgSchCellCb                *cell;
28544 RgSchDlSf                  *subFrm;
28545 RgSchUeCb                  *ue;
28546 U32                        bo;
28547 U32                        *effBo;
28548 RgSchDlHqProcCb            *proc;
28549 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28550 #endif
28551 {
28552    RgSchCmnDlUe     *ueDl;
28553    RgSchDlRbAlloc   *allocInfo;
28554    U8               numRb;
28555    U8               noTxLyrs;
28556    U8               precInfo;
28557    S16              ret;
28558    U8               precInfoAntIdx;
28559
28560    TRC2(rgSCHCmnDlTM3TxTx);
28561
28562    ret = ROK;
28563    ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
28564    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28565
28566    /* Integration_fix: SPS Proc shall always have only one Cw */
28567 #ifdef LTEMAC_SPS
28568 #ifdef FOUR_TX_ANTENNA
28569       if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28570                      (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28571 #else
28572    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28573          (ueDl->mimoInfo.forceTD))
28574 #endif
28575 #else
28576    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28577 #endif
28578    {
28579       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28580             &allocInfo->raType);
28581       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28582             bo, &numRb, effBo);
28583       if (ret == RFAILED)
28584       {
28585          /* If allocation couldn't be made then return */
28586          RETVOID;
28587       }
28588       noTxLyrs = 1;
28589       precInfo = 0; /* TD */
28590    }
28591    else /* Precoding */
28592    {
28593       allocInfo->dciFormat = TFU_DCI_FORMAT_2A;
28594       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28595
28596       /* Spatial Multiplexing using 2 CWs */
28597       ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28598       if (ret == RFAILED)
28599       {
28600          /* If allocation couldn't be made then return */
28601          RETVOID;
28602       }
28603       noTxLyrs = ueDl->mimoInfo.ri;
28604       precInfoAntIdx = cell->numTxAntPorts/2 - 1;
28605       RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, getPrecInfoFunc[0], precInfoAntIdx);
28606       precInfo = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28607    }
28608
28609 #ifdef LTEMAC_SPS
28610    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28611 #endif
28612    {
28613       /* Adding UE to RbAllocInfo TX Lst */
28614       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28615    }
28616    /* Fill UE allocInfo scrath pad */
28617    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28618          precInfo, noTxLyrs, subFrm);
28619
28620    RETVOID;
28621 }
28622
28623 \f
28624 /**
28625  * @brief This function handles Retx allocation in case of TM4 UEs
28626  *        where previously both the TBs were ACKED and ACKED
28627  *        respectively.
28628  *
28629  * @details
28630  *
28631  *     Function: rgSCHCmnDlTM4TxTx
28632  *     Purpose:  Reached here for a TM4 UE's HqP's fresh allocation
28633  *                  where both the TBs are free for TX scheduling.
28634  *               If forceTD flag is set
28635  *                  perform TD on CW1 with TB1.
28636  *                  precInfo = 0
28637  *               else
28638  *                  DCI Format = 2.
28639  *                  RA Type = Type0.
28640  *                  If Rank == 1
28641  *                     Single layer precoding of TB1 on CW1.
28642  *                     Set precoding info.
28643  *                  else
28644  *                     RI layered precoding 2 TB on 2 CW.
28645  *                     Set precoding info.
28646  *               Add UE to cellAllocInfo.
28647  *               Fill ueAllocInfo.
28648  *
28649  *              effBo is set to a non-zero value if allocation is
28650  *              successful.
28651  *
28652  *     Invoked by: rgSCHCmnDlAllocRbTM4
28653  *
28654  *  @param[in]  RgSchCellCb           *cell
28655  *  @param[in]  RgSchDlSf             *subFrm
28656  *  @param[in]  RgSchUeCb             *ue
28657  *  @param[in]  U32                   bo
28658  *  @param[out] U32                   *effBo
28659  *  @param[in]  RgSchDlHqProcCb       *proc
28660  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28661  *  @return  Void
28662  *
28663  **/
28664 #ifdef ANSI
28665 PRIVATE Void rgSCHCmnDlTM4TxTx
28666 (
28667 RgSchCellCb                *cell,
28668 RgSchDlSf                  *subFrm,
28669 RgSchUeCb                  *ue,
28670 U32                        bo,
28671 U32                        *effBo,
28672 RgSchDlHqProcCb            *proc,
28673 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28674 )
28675 #else
28676 PRIVATE Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28677 RgSchCellCb                *cell;
28678 RgSchDlSf                  *subFrm;
28679 RgSchUeCb                  *ue;
28680 U32                        bo;
28681 U32                        *effBo;
28682 RgSchDlHqProcCb            *proc;
28683 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28684 #endif
28685 {
28686    RgSchCmnDlUe     *ueDl;
28687    RgSchDlRbAlloc   *allocInfo;
28688    U8               numRb;
28689    U8               precInfo;
28690    U8               noTxLyrs;
28691    U8               precInfoAntIdx;
28692    S16              ret;
28693
28694    TRC2(rgSCHCmnDlTM4TxTx);
28695
28696    ret       = ROK;
28697    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
28698    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
28699
28700    /* Integration_fix: SPS Proc shall always have only one Cw */
28701 #ifdef LTEMAC_SPS
28702 #ifdef FOUR_TX_ANTENNA
28703    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28704                   (ueDl->mimoInfo.forceTD) || proc->hasDcch) /*Chandra Avoid DCCH to be SM */
28705 #else
28706    if ((RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc)) ||
28707          (ueDl->mimoInfo.forceTD))
28708 #endif
28709 #else
28710    if (ueDl->mimoInfo.forceTD) /* Transmit Diversity (TD) */
28711 #endif
28712    {
28713       allocInfo->dciFormat = rgSCHCmnSlctPdcchFrmt(cell, ue, \
28714             &allocInfo->raType);
28715
28716       ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28717             bo, &numRb, effBo);
28718       if (ret == RFAILED)
28719       {
28720          /* If allocation couldn't be made then return */
28721          RETVOID;
28722       }
28723       noTxLyrs = 1;
28724       precInfo = 0; /* TD */
28725    }
28726    else /* Precoding */
28727    {
28728       allocInfo->dciFormat = TFU_DCI_FORMAT_2;
28729       allocInfo->raType    = RG_SCH_CMN_RA_TYPE0;
28730
28731       if (ueDl->mimoInfo.ri == 1)
28732       {
28733          /* Single Layer SM using FORMAT 2 */
28734          ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
28735                bo, &numRb, effBo);
28736          if (ret == RFAILED)
28737          {
28738             /* If allocation couldn't be made then return */
28739             RETVOID;
28740          }
28741          noTxLyrs = 1;
28742          precInfo = 0; /* PrecInfo as 0 for RI=1*/
28743       }
28744       else
28745       {
28746          /* Spatial Multiplexing using 2 CWs */
28747          ret = rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, &numRb, effBo);
28748          if (ret == RFAILED)
28749          {
28750             /* If allocation couldn't be made then return */
28751             RETVOID;
28752          }
28753          noTxLyrs = ueDl->mimoInfo.ri;
28754          precInfoAntIdx = cell->numTxAntPorts/2 - 1; 
28755          precInfo = (getPrecInfoFunc[1][precInfoAntIdx])(cell, ue, noTxLyrs, TRUE);
28756       }
28757    }
28758
28759    
28760 #ifdef LTEMAC_SPS
28761    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
28762 #endif
28763    {
28764       /* Adding UE to RbAllocInfo TX Lst */
28765       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
28766    }
28767
28768    /* Fill UE allocInfo scrath pad */
28769    RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
28770          precInfo, noTxLyrs, subFrm);
28771
28772    RETVOID;
28773 }
28774
28775 \f
28776 /**
28777  * @brief This function determines the RBs and Bytes required for BO
28778  *        transmission for UEs configured with TM 4.
28779  *
28780  * @details
28781  *
28782  *     Function: rgSCHCmnDlAllocTxRbTM4
28783  *     Purpose:  Invokes the functionality particular to the
28784  *               current state of the TBs of the "proc".
28785  *
28786  *               Reference Parameter effBo is filled with alloced bytes.
28787  *               Returns RFAILED if BO not satisfied at all.
28788  *
28789  *     Invoked by: rgSCHCmnDlAllocTxRb
28790  *
28791  *  @param[in]  RgSchCellCb           *cell
28792  *  @param[in]  RgSchDlSf             *subFrm
28793  *  @param[in]  RgSchUeCb             *ue
28794  *  @param[in]  U32                   bo
28795  *  @param[out] U32                   *effBo
28796  *  @param[in]  RgSchDlHqProcCb       *proc
28797  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28798  *  @return  Void
28799  *
28800  **/
28801 #ifdef ANSI
28802 PRIVATE Void rgSCHCmnDlAllocTxRbTM4
28803 (
28804 RgSchCellCb                *cell,
28805 RgSchDlSf                  *subFrm,
28806 RgSchUeCb                  *ue,
28807 U32                        bo,
28808 U32                        *effBo,
28809 RgSchDlHqProcCb            *proc,
28810 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28811 )
28812 #else
28813 PRIVATE Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28814 RgSchCellCb                *cell;
28815 RgSchDlSf                  *subFrm;
28816 RgSchUeCb                  *ue;
28817 U32                        bo;
28818 U32                        *effBo;
28819 RgSchDlHqProcCb            *proc;
28820 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28821 #endif
28822 {
28823    TRC2(rgSCHCmnDlAllocTxRbTM4);
28824
28825    /* Both TBs free for TX allocation */
28826    rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
28827          proc, cellWdAllocInfo);
28828
28829    RETVOID;
28830 }
28831
28832 \f
28833 /**
28834  * @brief This function determines the RBs and Bytes required for BO
28835  *        retransmission for UEs configured with TM 4.
28836  *
28837  * @details
28838  *
28839  *     Function: rgSCHCmnDlAllocRetxRbTM4
28840  *     Purpose:  Invokes the functionality particular to the
28841  *               current state of the TBs of the "proc".
28842  *
28843  *               Reference Parameter effBo is filled with alloced bytes.
28844  *               Returns RFAILED if BO not satisfied at all.
28845  *
28846  *     Invoked by: rgSCHCmnDlAllocRetxRb
28847  *
28848  *  @param[in]  RgSchCellCb           *cell
28849  *  @param[in]  RgSchDlSf             *subFrm
28850  *  @param[in]  RgSchUeCb             *ue
28851  *  @param[in]  U32                   bo
28852  *  @param[out] U32                   *effBo
28853  *  @param[in]  RgSchDlHqProcCb       *proc
28854  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28855  *  @return  Void
28856  *
28857  **/
28858 #ifdef ANSI
28859 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4
28860 (
28861 RgSchCellCb                *cell,
28862 RgSchDlSf                  *subFrm,
28863 RgSchUeCb                  *ue,
28864 U32                        bo,
28865 U32                        *effBo,
28866 RgSchDlHqProcCb            *proc,
28867 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28868 )
28869 #else
28870 PRIVATE Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28871 RgSchCellCb                *cell;
28872 RgSchDlSf                  *subFrm;
28873 RgSchUeCb                  *ue;
28874 U32                        bo;
28875 U32                        *effBo;
28876 RgSchDlHqProcCb            *proc;
28877 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28878 #endif
28879 {
28880    TRC2(rgSCHCmnDlAllocRetxRbTM4);
28881
28882    if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
28883          (proc->tbInfo[1].state == HQ_TB_NACKED))
28884    {
28885       /* Both TBs require RETX allocation */
28886       rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo,\
28887             proc, cellWdAllocInfo);
28888    }
28889    else
28890    {
28891       /* One of the TBs need RETX allocation. Other TB may/maynot
28892        * be available for new TX allocation. */
28893       rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo,\
28894             proc, cellWdAllocInfo);
28895    }
28896
28897    RETVOID;
28898 }
28899
28900 #ifdef RG_UNUSED
28901 \f
28902 /**
28903  * @brief This function determines the RBs and Bytes required for BO
28904  *        transmission for UEs configured with TM 5.
28905  *
28906  * @details
28907  *
28908  *     Function: rgSCHCmnDlAllocTxRbTM5
28909  *     Purpose:
28910  *
28911  *               Reference Parameter effBo is filled with alloced bytes.
28912  *               Returns RFAILED if BO not satisfied at all.
28913  *
28914  *     Invoked by: rgSCHCmnDlAllocTxRb
28915  *
28916  *  @param[in]  RgSchCellCb           *cell
28917  *  @param[in]  RgSchDlSf             *subFrm
28918  *  @param[in]  RgSchUeCb             *ue
28919  *  @param[in]  U32                   bo
28920  *  @param[out] U32                   *effBo
28921  *  @param[in]  RgSchDlHqProcCb       *proc
28922  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28923  *  @return Void
28924  *
28925  **/
28926 #ifdef ANSI
28927 PRIVATE Void rgSCHCmnDlAllocTxRbTM5
28928 (
28929 RgSchCellCb                *cell,
28930 RgSchDlSf                  *subFrm,
28931 RgSchUeCb                  *ue,
28932 U32                        bo,
28933 U32                        *effBo,
28934 RgSchDlHqProcCb            *proc,
28935 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28936 )
28937 #else
28938 PRIVATE Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28939 RgSchCellCb                *cell;
28940 RgSchDlSf                  *subFrm;
28941 RgSchUeCb                  *ue;
28942 U32                        bo;
28943 U32                        *effBo;
28944 RgSchDlHqProcCb            *proc;
28945 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
28946 #endif
28947 {
28948    TRC2(rgSCHCmnDlAllocTxRbTM5);
28949 #if (ERRCLASS & ERRCLS_DEBUG)
28950    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
28951 #endif
28952    RETVOID;
28953 }
28954
28955 \f
28956 /**
28957  * @brief This function determines the RBs and Bytes required for BO
28958  *        retransmission for UEs configured with TM 5.
28959  *
28960  * @details
28961  *
28962  *     Function: rgSCHCmnDlAllocRetxRbTM5
28963  *     Purpose:
28964  *
28965  *               Reference Parameter effBo is filled with alloced bytes.
28966  *               Returns RFAILED if BO not satisfied at all.
28967  *
28968  *     Invoked by: rgSCHCmnDlAllocRetxRb
28969  *
28970  *  @param[in]  RgSchCellCb           *cell
28971  *  @param[in]  RgSchDlSf             *subFrm
28972  *  @param[in]  RgSchUeCb             *ue
28973  *  @param[in]  U32                   bo
28974  *  @param[out] U32                   *effBo
28975  *  @param[in]  RgSchDlHqProcCb       *proc
28976  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
28977  *  @return Void
28978  *
28979  **/
28980 #ifdef ANSI
28981 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5
28982 (
28983 RgSchCellCb                *cell,
28984 RgSchDlSf                  *subFrm,
28985 RgSchUeCb                  *ue,
28986 U32                        bo,
28987 U32                        *effBo,
28988 RgSchDlHqProcCb            *proc,
28989 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
28990 )
28991 #else
28992 PRIVATE Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
28993 RgSchCellCb                *cell;
28994 RgSchDlSf                  *subFrm;
28995 RgSchUeCb                  *ue;
28996 U32                        bo;
28997 U32                        *effBo;
28998 RgSchDlHqProcCb            *proc;
28999 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29000 #endif
29001 {
29002    TRC2(rgSCHCmnDlAllocRetxRbTM5);
29003 #if (ERRCLASS & ERRCLS_DEBUG)
29004    RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
29005 #endif
29006    RETVOID;
29007 }
29008 #endif
29009
29010 \f
29011 /**
29012  * @brief This function determines the RBs and Bytes required for BO
29013  *        transmission for UEs configured with TM 6.
29014  *
29015  * @details
29016  *
29017  *     Function: rgSCHCmnDlAllocTxRbTM6
29018  *     Purpose:
29019  *
29020  *               Reference Parameter effBo is filled with alloced bytes.
29021  *               Returns RFAILED if BO not satisfied at all.
29022  *
29023  *     Invoked by: rgSCHCmnDlAllocTxRb
29024  *
29025  *  @param[in]  RgSchCellCb           *cell
29026  *  @param[in]  RgSchDlSf             *subFrm
29027  *  @param[in]  RgSchUeCb             *ue
29028  *  @param[in]  U32                   bo
29029  *  @param[out] U32                   *effBo
29030  *  @param[in]  RgSchDlHqProcCb       *proc
29031  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29032  *  @return Void
29033  *
29034  **/
29035 #ifdef ANSI
29036 PRIVATE Void rgSCHCmnDlAllocTxRbTM6
29037 (
29038 RgSchCellCb                *cell,
29039 RgSchDlSf                  *subFrm,
29040 RgSchUeCb                  *ue,
29041 U32                        bo,
29042 U32                        *effBo,
29043 RgSchDlHqProcCb            *proc,
29044 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29045 )
29046 #else
29047 PRIVATE Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29048 RgSchCellCb                *cell;
29049 RgSchDlSf                  *subFrm;
29050 RgSchUeCb                  *ue;
29051 U32                        bo;
29052 U32                        *effBo;
29053 RgSchDlHqProcCb            *proc;
29054 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29055 #endif
29056 {
29057    RgSchDlRbAlloc *allocInfo;
29058    RgSchCmnDlUe   *ueDl;
29059    S16            ret;
29060    U8             numRb;
29061
29062    TRC2(rgSCHCmnDlAllocTxRbTM6);
29063
29064    ret       = ROK;
29065    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29066    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29067
29068    if (ueDl->mimoInfo.forceTD)
29069    {
29070       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29071       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29072    }
29073    else
29074    {
29075       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29076       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29077       /* Fill precoding information for FORMAT 1B */
29078       /* First 4 least significant bits to indicate PMI.
29079        * 4th most significant corresponds to pmi Confirmation.
29080        */
29081       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29082       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29083    }
29084    ret = rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, &proc->tbInfo[0],\
29085          bo, &numRb, effBo);
29086    if (ret == RFAILED)
29087    {
29088       /* If allocation couldn't be made then return */
29089       RETVOID;
29090    }
29091    
29092 #ifdef LTEMAC_SPS
29093    if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
29094 #endif
29095    {
29096       /* Adding UE to RbAllocInfo TX Lst */
29097       rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
29098    }
29099    /* Fill UE alloc Info */
29100    allocInfo->rbsReq = numRb;
29101    allocInfo->dlSf   = subFrm;
29102    RETVOID;
29103 }
29104
29105 \f
29106 /**
29107  * @brief This function determines the RBs and Bytes required for BO
29108  *        retransmission for UEs configured with TM 6.
29109  *
29110  * @details
29111  *
29112  *     Function: rgSCHCmnDlAllocRetxRbTM6
29113  *     Purpose:
29114  *
29115  *               Reference Parameter effBo is filled with alloced bytes.
29116  *               Returns RFAILED if BO not satisfied at all.
29117  *
29118  *     Invoked by: rgSCHCmnDlAllocRetxRb
29119  *
29120  *  @param[in]  RgSchCellCb           *cell
29121  *  @param[in]  RgSchDlSf             *subFrm
29122  *  @param[in]  RgSchUeCb             *ue
29123  *  @param[in]  U32                   bo
29124  *  @param[out] U32                   *effBo
29125  *  @param[in]  RgSchDlHqProcCb       *proc
29126  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29127  *  @return Void
29128  *
29129  **/
29130 #ifdef ANSI
29131 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6
29132 (
29133 RgSchCellCb                *cell,
29134 RgSchDlSf                  *subFrm,
29135 RgSchUeCb                  *ue,
29136 U32                        bo,
29137 U32                        *effBo,
29138 RgSchDlHqProcCb            *proc,
29139 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29140 )
29141 #else
29142 PRIVATE Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29143 RgSchCellCb                *cell;
29144 RgSchDlSf                  *subFrm;
29145 RgSchUeCb                  *ue;
29146 U32                        bo;
29147 U32                        *effBo;
29148 RgSchDlHqProcCb            *proc;
29149 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29150 #endif
29151 {
29152    RgSchDlRbAlloc *allocInfo;
29153    RgSchCmnDlUe   *ueDl;
29154    S16            ret;
29155    U8             numRb;
29156
29157    TRC2(rgSCHCmnDlAllocRetxRbTM6);
29158
29159    ret       = ROK;
29160    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29161    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29162
29163    if (ueDl->mimoInfo.forceTD)
29164    {
29165       allocInfo->dciFormat = TFU_DCI_FORMAT_1A;
29166       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29167    }
29168    else
29169    {
29170       allocInfo->dciFormat = TFU_DCI_FORMAT_1B;
29171       allocInfo->raType    = RG_SCH_CMN_RA_TYPE2;
29172       /* Fill precoding information for FORMAT 1B */
29173       /* First 4 least significant bits to indicate PMI.
29174        * 4th most significant corresponds to pmi Confirmation.
29175        */
29176       allocInfo->mimoAllocInfo.precIdxInfo |= ue->mimoInfo.puschFdbkVld << 4;
29177       allocInfo->mimoAllocInfo.precIdxInfo |= ueDl->mimoInfo.pmi;
29178    }
29179
29180    /* Get the Allocation in terms of RBs that are required for
29181     * this retx of TB1 */
29182    ret = rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, &proc->tbInfo[0],
29183          1, &numRb, effBo);
29184    if (ret == RFAILED)
29185    {
29186       /* Allocation couldn't be made for Retx */
29187       rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
29188       RETVOID;
29189    }
29190    /* Adding UE to allocInfo RETX Lst */
29191    rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
29192    /* Fill UE alloc Info */
29193    allocInfo->rbsReq = numRb;
29194    allocInfo->dlSf   = subFrm;
29195    RETVOID;
29196 }
29197
29198 \f
29199 /**
29200  * @brief This function determines the RBs and Bytes required for BO
29201  *        transmission for UEs configured with TM 7.
29202  *
29203  * @details
29204  *
29205  *     Function: rgSCHCmnDlAllocTxRbTM7
29206  *     Purpose:
29207  *
29208  *               Reference Parameter effBo is filled with alloced bytes.
29209  *               Returns RFAILED if BO not satisfied at all.
29210  *
29211  *     Invoked by: rgSCHCmnDlAllocTxRb
29212  *
29213  *  @param[in]  RgSchCellCb           *cell
29214  *  @param[in]  RgSchDlSf             *subFrm
29215  *  @param[in]  RgSchUeCb             *ue
29216  *  @param[in]  U32                   bo
29217  *  @param[out] U32                   *effBo
29218  *  @param[in]  RgSchDlHqProcCb       *proc
29219  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29220  *  @return Void
29221  *
29222  **/
29223 #ifdef ANSI
29224 PRIVATE Void rgSCHCmnDlAllocTxRbTM7
29225 (
29226 RgSchCellCb                *cell,
29227 RgSchDlSf                  *subFrm,
29228 RgSchUeCb                  *ue,
29229 U32                        bo,
29230 U32                        *effBo,
29231 RgSchDlHqProcCb            *proc,
29232 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29233 )
29234 #else
29235 PRIVATE Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29236 RgSchCellCb                *cell;
29237 RgSchDlSf                  *subFrm;
29238 RgSchUeCb                  *ue;
29239 U32                        bo;
29240 U32                        *effBo;
29241 RgSchDlHqProcCb            *proc;
29242 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29243 #endif
29244 {
29245    TRC2(rgSCHCmnDlAllocTxRbTM7);
29246    rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29247    RETVOID;
29248 }
29249
29250 \f
29251 /**
29252  * @brief This function determines the RBs and Bytes required for BO
29253  *        retransmission for UEs configured with TM 7.
29254  *
29255  * @details
29256  *
29257  *     Function: rgSCHCmnDlAllocRetxRbTM7
29258  *     Purpose:
29259  *
29260  *               Reference Parameter effBo is filled with alloced bytes.
29261  *               Returns RFAILED if BO not satisfied at all.
29262  *
29263  *     Invoked by: rgSCHCmnDlAllocRetxRb
29264  *
29265  *  @param[in]  RgSchCellCb           *cell
29266  *  @param[in]  RgSchDlSf             *subFrm
29267  *  @param[in]  RgSchUeCb             *ue
29268  *  @param[in]  U32                   bo
29269  *  @param[out] U32                   *effBo
29270  *  @param[in]  RgSchDlHqProcCb       *proc
29271  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29272  *  @return Void
29273  *
29274  **/
29275 #ifdef ANSI
29276 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7
29277 (
29278 RgSchCellCb                *cell,
29279 RgSchDlSf                  *subFrm,
29280 RgSchUeCb                  *ue,
29281 U32                        bo,
29282 U32                        *effBo,
29283 RgSchDlHqProcCb            *proc,
29284 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29285 )
29286 #else
29287 PRIVATE Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29288 RgSchCellCb                *cell;
29289 RgSchDlSf                  *subFrm;
29290 RgSchUeCb                  *ue;
29291 U32                        bo;
29292 U32                        *effBo;
29293 RgSchDlHqProcCb            *proc;
29294 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29295 #endif
29296 {
29297    TRC2(rgSCHCmnDlAllocRetxRbTM7);
29298    rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
29299    RETVOID;
29300 }
29301
29302 \f
29303 /**
29304  * @brief This function invokes the TM specific DL TX RB Allocation routine.
29305  *
29306  * @details
29307  *
29308  *     Function: rgSCHCmnDlAllocTxRb
29309  *     Purpose:  This function invokes the TM specific
29310  *               DL TX RB Allocation routine.
29311  *
29312  *     Invoked by: Specific Schedulers
29313  *
29314  *  @param[in]  RgSchCellCb           *cell
29315  *  @param[in]  RgSchDlSf             *subFrm
29316  *  @param[in]  RgSchUeCb             *ue
29317  *  @param[in]  U32                   bo
29318  *  @param[out] U32                   *effBo
29319  *  @param[in]  RgSchDlHqProcCb       *proc
29320  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29321  *  @return  S16
29322  *
29323  **/
29324 #ifdef ANSI
29325 PUBLIC S16 rgSCHCmnDlAllocTxRb
29326 (
29327 RgSchCellCb                *cell,
29328 RgSchDlSf                  *subFrm,
29329 RgSchUeCb                  *ue,
29330 U32                        bo,
29331 U32                        *effBo,
29332 RgSchDlHqProcCb            *proc,
29333 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29334 )
29335 #else
29336 PUBLIC S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29337 RgSchCellCb                *cell;
29338 RgSchDlSf                  *subFrm;
29339 RgSchUeCb                  *ue;
29340 U32                        bo;
29341 U32                        *effBo;
29342 RgSchDlHqProcCb            *proc;
29343 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29344 #endif
29345 {
29346    U32                     newSchBits = 0;
29347    U32                     prevSchBits = 0;
29348    RgSchDlRbAlloc          *allocInfo;
29349
29350    TRC2(rgSCHCmnDlAllocTxRb);
29351
29352    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29353    {
29354       ue->dl.aggTbBits = 0;
29355    }
29356    *effBo = 0;
29357
29358    /* Calculate totals bits previously allocated */
29359    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29360    if (allocInfo->tbInfo[0].schdlngForTb)
29361    {
29362       prevSchBits += allocInfo->tbInfo[0].bytesReq;
29363    }
29364    if (allocInfo->tbInfo[1].schdlngForTb)
29365    {
29366       prevSchBits += allocInfo->tbInfo[1].bytesReq;
29367    }
29368
29369    /* Call TM specific RB allocation routine */
29370    (dlAllocTxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29371          proc, cellWdAllocInfo);
29372
29373    if (*effBo)
29374    {
29375       /* Calculate totals bits newly allocated */
29376       if (allocInfo->tbInfo[0].schdlngForTb)
29377       {
29378          newSchBits += allocInfo->tbInfo[0].bytesReq;
29379       }
29380       if (allocInfo->tbInfo[1].schdlngForTb)
29381       {
29382          newSchBits += allocInfo->tbInfo[1].bytesReq;
29383       }
29384       if (newSchBits > prevSchBits)
29385       {
29386          ue->dl.aggTbBits += ((newSchBits - prevSchBits) * 8);
29387          RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29388       }
29389    }
29390
29391    RETVALUE(ROK);
29392 }
29393
29394 /* DwPTS Scheduling Changes Start */
29395 #ifdef LTE_TDD
29396 /**
29397  * @brief Retransmit decision for TDD. Retx is avoided in below cases
29398  *        1) DL Sf       -> Spl Sf
29399  *        2) DL SF       -> DL SF 0 
29400  *
29401  * @details
29402  *
29403  *     Function: rgSCHCmnRetxAvoidTdd 
29404  *     Purpose: Avoid allocating RETX for cases 1, 2 
29405  * 
29406  *     Invoked by: rgSCHCmnRetxAvoidTdd 
29407  *
29408  *  @param[in]  RgSchDlSf             *curSf
29409  *  @param[in]  RgSchCellCb           *cell
29410  *  @param[in]  RgSchDlHqProcCb       *proc
29411  *  @return  Bool 
29412  *
29413  **/
29414 #ifdef ANSI
29415 PUBLIC Bool rgSCHCmnRetxAvoidTdd 
29416 (
29417 RgSchDlSf                  *curSf,
29418 RgSchCellCb                *cell,
29419 RgSchDlHqProcCb            *proc
29420 )
29421 #else
29422 PUBLIC Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
29423 RgSchDlSf                  *curSf;
29424 RgSchCellCb                *cell;
29425 RgSchDlHqProcCb            *proc;
29426 #endif
29427 {
29428    RgSchTddSfType   txSfType = 0;
29429
29430    TRC2(rgSCHCmnRetxAvoidTdd);
29431
29432    /* Get the RBs of TB that will be retransmitted */
29433    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29434    {
29435       txSfType = proc->tbInfo[0].sfType;
29436
29437 #ifdef XEON_SPECIFIC_CHANGES
29438 #ifndef XEON_TDD_SPCL
29439       /* Avoid re-transmission on Normal SF when the corresponding TB wss transmitted on SPCL SF */
29440       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29441       {
29442          RETVALUE(TRUE);
29443       }
29444 #endif
29445 #endif
29446    }
29447    if (proc->tbInfo[1].state == HQ_TB_NACKED) 
29448    {
29449       /* Select the TxSf with the highest num of possible REs 
29450        * In ascending order -> 1) SPL SF 2) DL_SF_0 3) DL_SF */
29451       txSfType = RGSCH_MAX(txSfType, proc->tbInfo[1].sfType);
29452
29453 #ifdef XEON_SPECIFIC_CHANGES
29454 #ifndef XEON_TDD_SPCL
29455       /* Avoid re-transmission on Normal SF when the corresponding TB wss tranmitted on SPCL SF */
29456       if(txSfType <= RG_SCH_SPL_SF_DATA && curSf->sfType >= RG_SCH_DL_SF_0)
29457       {
29458          RETVALUE(TRUE);
29459       }
29460 #endif
29461 #endif
29462    }
29463
29464    if (txSfType > curSf->sfType)
29465    {
29466       /* Avoid retx */
29467       RETVALUE(TRUE);
29468    }
29469    
29470    /* Allow Retx */
29471    RETVALUE(FALSE);
29472 }
29473
29474 #else
29475 /* DwPTS Scheduling Changes End */
29476 \f
29477 /**
29478  * @brief Avoid allocating RETX incase of collision
29479  * with reserved resources for BCH/PSS/SSS occassions.
29480  *
29481  * @details
29482  *
29483  *     Function: rgSCHCmnRetxAllocAvoid 
29484  *     Purpose: Avoid allocating RETX incase of collision
29485  * with reserved resources for BCH/PSS/SSS occassions 
29486  *
29487  *     Invoked by: rgSCHCmnDlAllocRetxRb 
29488  *
29489  *  @param[in]  RgSchDlSf             *subFrm
29490  *  @param[in]  RgSchUeCb             *ue
29491  *  @param[in]  RgSchDlHqProcCb       *proc
29492  *  @return  Bool 
29493  *
29494  **/
29495 #ifdef ANSI
29496 PUBLIC Bool rgSCHCmnRetxAllocAvoid 
29497 (
29498 RgSchDlSf                  *subFrm,
29499 RgSchCellCb                *cell,
29500 RgSchDlHqProcCb            *proc
29501 )
29502 #else
29503 PUBLIC Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
29504 RgSchDlSf                  *subFrm;
29505 RgSchCellCb                *cell;
29506 RgSchDlHqProcCb            *proc;
29507 #endif
29508 {
29509    U8          reqRbs;
29510
29511    TRC2(rgSCHCmnRetxAllocAvoid);
29512
29513    if (proc->tbInfo[0].state == HQ_TB_NACKED)
29514    {
29515       reqRbs = proc->tbInfo[0].dlGrnt.numRb;    
29516    }
29517    else
29518    {
29519       reqRbs = proc->tbInfo[1].dlGrnt.numRb;    
29520    }
29521    /* Consider the dlGrnt.numRb of the Retransmitting proc->tbInfo
29522     * and current available RBs to determine if this RETX TB
29523     * will collide with the BCH/PSS/SSS occassion */
29524    if (subFrm->sfNum % 5 == 0)
29525    {
29526       if ((subFrm->bwAssigned < cell->pbchRbEnd) &&
29527           (((subFrm->bwAssigned + reqRbs) - cell->pbchRbStart) > 0))
29528       {
29529          RETVALUE(TRUE);
29530       }
29531    }
29532    RETVALUE(FALSE);
29533 }
29534
29535 #endif
29536
29537 \f
29538 /**
29539  * @brief This function invokes the TM specific DL RETX RB Allocation routine.
29540  *
29541  * @details
29542  *
29543  *     Function: rgSCHCmnDlAllocRetxRb
29544  *     Purpose:  This function invokes the TM specific
29545  *               DL RETX RB Allocation routine.
29546  *
29547  *     Invoked by: Specific Schedulers
29548  *
29549  *  @param[in]  RgSchCellCb           *cell
29550  *  @param[in]  RgSchDlSf             *subFrm
29551  *  @param[in]  RgSchUeCb             *ue
29552  *  @param[in]  U32                   bo
29553  *  @param[out] U32                   *effBo
29554  *  @param[in]  RgSchDlHqProcCb       *proc
29555  *  @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
29556  *  @return  S16
29557  *
29558  **/
29559 #ifdef ANSI
29560 PUBLIC S16 rgSCHCmnDlAllocRetxRb
29561 (
29562 RgSchCellCb                *cell,
29563 RgSchDlSf                  *subFrm,
29564 RgSchUeCb                  *ue,
29565 U32                        bo,
29566 U32                        *effBo,
29567 RgSchDlHqProcCb            *proc,
29568 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo
29569 )
29570 #else
29571 PUBLIC S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
29572 RgSchCellCb                *cell;
29573 RgSchDlSf                  *subFrm;
29574 RgSchUeCb                  *ue;
29575 U32                        bo;
29576 U32                        *effBo;
29577 RgSchDlHqProcCb            *proc;
29578 RgSchCmnDlRbAllocInfo      *cellWdAllocInfo;
29579 #endif
29580 {
29581    U32                     newSchBits = 0;
29582    RgSchDlRbAlloc          *allocInfo;
29583
29584    TRC2(rgSCHCmnDlAllocRetxRb);
29585
29586    if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
29587    {
29588       ue->dl.aggTbBits = 0;
29589    }
29590  
29591    *effBo = 0;
29592    /* Check for DL BW exhaustion */
29593    if (subFrm->bw <= subFrm->bwAssigned)
29594    {
29595       RETVALUE(RFAILED);
29596    }
29597    /* Call TM specific RB allocation routine */
29598    (dlAllocRetxRbFunc[ue->mimoInfo.txMode - 1])(cell, subFrm, ue, bo, effBo, \
29599          proc, cellWdAllocInfo);
29600
29601    if (*effBo)
29602    {
29603       allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29604       /* Calculate totals bits newly allocated */
29605       if (allocInfo->tbInfo[0].schdlngForTb)
29606       {
29607          newSchBits += allocInfo->tbInfo[0].bytesReq;
29608       }
29609       if (allocInfo->tbInfo[1].schdlngForTb)
29610       {
29611          newSchBits += allocInfo->tbInfo[1].bytesReq;
29612       }
29613       ue->dl.aggTbBits += (newSchBits * 8);
29614       RGSCHCPYTIMEINFO((cell->crntTime),(ue->dl.lstSchTime))
29615    }
29616    
29617    RETVALUE(ROK);
29618 }
29619
29620 \f
29621 /**
29622  * @brief This function determines the RBs and Bytes required for
29623  *        Transmission on 1 CW.
29624  *
29625  * @details
29626  *
29627  *     Function: rgSCHCmnDlAlloc1CwTxRb
29628  *     Purpose:  This function determines the RBs and Bytes required
29629  *               for Transmission of DL SVC BO on 1 CW.
29630  *               Also, takes care of SVC by SVC allocation by tracking
29631  *               previous SVCs allocations.
29632  *               Returns RFAILED if BO not satisfied at all.
29633  *
29634  *     Invoked by: DL UE Allocation
29635  *
29636  *  @param[in]  RgSchCellCb      *cell
29637  *  @param[in]  RgSchDlSf        *subFrm
29638  *  @param[in]  RgSchUeCb        *ue
29639  *  @param[in]  RgSchDlHqTbCb    *tbInfo
29640  *  @param[in]  U32              bo
29641  *  @param[out] U8               *numRb
29642  *  @param[out] U32              *effBo
29643  *  @return  S16
29644  *
29645  **/
29646 #ifdef ANSI
29647 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb
29648 (
29649 RgSchCellCb                *cell,
29650 RgSchDlSf                  *subFrm,
29651 RgSchUeCb                  *ue,
29652 RgSchDlHqTbCb              *tbInfo,
29653 U32                        bo,
29654 U8                         *numRb,
29655 U32                        *effBo
29656 )
29657 #else
29658 PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
29659 RgSchCellCb                *cell;
29660 RgSchDlSf                  *subFrm;
29661 RgSchUeCb                  *ue;
29662 RgSchDlHqTbCb              *tbInfo;
29663 U32                        bo;
29664 U8                         *numRb;
29665 U32                        *effBo;
29666 #endif
29667 {
29668    U32                tbSz;
29669    U8                 imcs;
29670    U8                 iTbs;
29671    RgSchCmnDlUe       *ueDl;
29672    RgSchDlRbAlloc     *allocInfo;
29673    U32                oldReq;
29674    U32                reqBytes;
29675    /* Correcting wrap around issue.
29676     * This change has been done at mutliple places in this function.*/
29677    U32                tempNumRb;
29678    TRC2(rgSCHCmnDlAlloc1CwTxRb);
29679
29680    reqBytes  = bo;
29681    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29682    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29683    oldReq    = ueDl->outStndAlloc;
29684
29685 #ifdef RG_5GTF
29686    //TODO_SID: Currently setting max Tb size wrt to 5GTF TM3
29687    iTbs = ue->ue5gtfCb.mcs;
29688    ueDl->maxTbSz = MAX_5GTF_TB_SIZE * ue->ue5gtfCb.rank;
29689    ueDl->maxRb = MAX_5GTF_PRBS;
29690 #endif
29691    ueDl->outStndAlloc += bo;
29692    /* consider Cumulative amount of this BO and bytes so far allocated */
29693    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbSz/8);
29694    /* Get the number of REs needed for this bo. */
29695    //noRes = ((bo * 8 * 1024) / eff);
29696
29697    /* Get the number of RBs needed for this transmission */
29698    /* Number of RBs = No of REs / No of REs per RB       */
29699    //tempNumRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
29700    tempNumRb = MAX_5GTF_PRBS;
29701    tbSz = RGSCH_MIN(bo, (rgSch5gtfTbSzTbl[iTbs]/8) * ue->ue5gtfCb.rank);
29702
29703    /* DwPts Scheduling Changes End */
29704    *effBo = RGSCH_MIN(tbSz - oldReq, reqBytes);
29705
29706 #ifdef RG_5GTF
29707    //RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs);
29708    imcs = iTbs;
29709 #endif
29710
29711
29712    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbSz, \
29713          iTbs, imcs, tbInfo, ue->ue5gtfCb.rank);
29714    *numRb = (U8) tempNumRb;
29715    
29716    /* Update the subframe Allocated BW field */
29717    subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
29718    
29719    RETVALUE(ROK);
29720 }
29721
29722 \f
29723 /**
29724  * @brief This function is invoked in the event of any TB's allocation
29725  *  being underutilized by the specific scheduler. Here we reduce iMcs
29726  *  to increase redundancy and hence increase reception quality at UE.
29727  *
29728  * @details
29729  *
29730  *     Function: rgSCHCmnRdcImcsTxTb
29731  *     Purpose:  This function shall reduce the iMcs in accordance with
29732  *               the total consumed bytes by the UE at allocation
29733  *               finalization.
29734  *
29735  *     Invoked by: UE DL Allocation finalization routine
29736  *                 of specific scheduler.
29737  *
29738  *  @param[in]  RgSchDlRbAlloc   *allocInfo
29739  *  @param[in]  U8               tbInfoIdx
29740  *  @param[in]  U32              cnsmdBytes
29741  *  @return  Void
29742  *
29743  **/
29744 #ifdef ANSI
29745 PUBLIC Void rgSCHCmnRdcImcsTxTb
29746 (
29747 RgSchDlRbAlloc   *allocInfo,
29748 U8               tbInfoIdx,
29749 U32              cnsmdBytes
29750 )
29751 #else
29752 PUBLIC Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
29753 RgSchDlRbAlloc   *allocInfo;
29754 U8               tbInfoIdx;
29755 U32              cnsmdBytes;
29756 #endif
29757 {
29758    RETVOID;
29759    /*The below functionality is not needed.*/
29760    U8                 noLyr;
29761    U8                 iTbs;
29762    U16                numRb;
29763
29764    TRC2(rgSCHCmnRdcImcsTxTb);
29765
29766    iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
29767    noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
29768    numRb = allocInfo->rbsAlloc;
29769    if ( numRb > 0)
29770    {
29771       if ((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) == cnsmdBytes)
29772       {
29773          RETVOID;
29774       }
29775    }
29776    /* Get iTbs as suitable for the consumed bytes */
29777    while((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) > cnsmdBytes)
29778    {
29779       if (iTbs == 0)
29780       {
29781          RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].\
29782                tbCb->dlGrnt.iMcs);
29783          RETVOID;
29784       }
29785       iTbs--;
29786    }
29787    iTbs++;
29788    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].tbCb->dlGrnt.iMcs);
29789
29790    RETVOID;
29791 }
29792
29793 \f
29794 /**
29795  * @brief This function determines the RBs and Bytes required for
29796  *        Transmission on 2 CWs.
29797  *
29798  * @details
29799  *
29800  *     Function: rgSCHCmnDlAlloc2CwTxRb
29801  *     Purpose:  This function determines the RBs and Bytes required
29802  *               for Transmission of DL SVC BO on 2 CWs.
29803  *               Also, takes care of SVC by SVC allocation by tracking
29804  *               previous SVCs allocations.
29805  *               Returns RFAILED if BO not satisfied at all.
29806  *
29807  *     Invoked by: TM3 and TM4 DL UE Allocation
29808  *
29809  *  @param[in]  RgSchCellCb      *cell
29810  *  @param[in]  RgSchDlSf        *subFrm
29811  *  @param[in]  RgSchUeCb        *ue
29812  *  @param[in]  RgSchDlHqProcCb  *proc
29813  *  @param[in]  RgSchDlHqProcCb  bo
29814  *  @param[out] U8               *numRb
29815  *  @param[out] U32              *effBo
29816  *  @return  Void
29817  *
29818  **/
29819 #ifdef ANSI
29820 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb
29821 (
29822 RgSchCellCb                *cell,
29823 RgSchDlSf                  *subFrm,
29824 RgSchUeCb                  *ue,
29825 RgSchDlHqProcCb            *proc,
29826 U32                        bo,
29827 U8                         *numRbRef,
29828 U32                        *effBo
29829 )
29830 #else
29831 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
29832 RgSchCellCb                *cell;
29833 RgSchDlSf                  *subFrm;
29834 RgSchUeCb                  *ue;
29835 RgSchDlHqProcCb            *proc;
29836 U32                        bo;
29837 U8                         *numRbRef;
29838 U32                        *effBo;
29839 #endif
29840 {
29841    U32                noRes;
29842    U32                eff1, eff2;
29843    U32                tb1Sz, tb2Sz;
29844    U8                 imcs1, imcs2;
29845    U8                 noLyr1, noLyr2;
29846    U8                 iTbs1, iTbs2;
29847    RgSchCmnDlCell     *cellDl;
29848    RgSchCmnDlUe       *ueDl;
29849    RgSchDlRbAlloc     *allocInfo;
29850    U32                oldReq;
29851    U32                reqBytes;
29852    /* Fix: MUE_PERTTI_DL */
29853    U32                numRb;
29854    RgSchCmnCell       *cellSch = RG_SCH_CMN_GET_CELL(cell);
29855    U8                 cfi = cellSch->dl.currCfi;
29856    S16                availBw; 
29857    U32                availBits = 0;
29858 #ifdef LTE_ADV
29859    U32                boTmp = bo;
29860 #endif
29861
29862    TRC2(rgSCHCmnDlAlloc2CwTxRb);
29863
29864    reqBytes  = bo;
29865    cellDl    = RG_SCH_CMN_GET_DL_CELL(cell);
29866    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
29867    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
29868    oldReq    = ueDl->outStndAlloc;
29869
29870    
29871    if (ueDl->maxTbBits > ue->dl.aggTbBits)
29872    {
29873       availBits = ueDl->maxTbBits - ue->dl.aggTbBits;
29874    }
29875    /* check if we can further allocate to this UE */
29876    if ((ue->dl.aggTbBits >= ueDl->maxTbBits) ||
29877          (allocInfo->tbInfo[0].bytesReq >= ueDl->maxTbSz/8) ||
29878          (allocInfo->tbInfo[1].bytesReq >= ueDl->maxTbSz/8) ||
29879          (allocInfo->rbsReq >= ueDl->maxRb))
29880    {
29881       RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
29882             "rgSCHCmnDlAllocRb(): UEs max allocation exceed");
29883       RETVALUE(RFAILED);
29884    }
29885
29886    noLyr1 = ueDl->mimoInfo.cwInfo[0].noLyr;
29887    noLyr2 = ueDl->mimoInfo.cwInfo[1].noLyr;
29888
29889    /* If there is no CFI change, continue to use the BLER based
29890     * iTBS value */
29891    if (ueDl->lastCfi == cfi)
29892    {   
29893       iTbs1  = ueDl->mimoInfo.cwInfo[0].iTbs[noLyr1 - 1];
29894       iTbs2  = ueDl->mimoInfo.cwInfo[1].iTbs[noLyr2 - 1];
29895    }
29896    else
29897    {  
29898       U8 cqi = ueDl->mimoInfo.cwInfo[0].cqi;
29899 #ifdef LTE_TDD      
29900       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
29901 #else      
29902       iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
29903 #endif         
29904
29905       cqi = ueDl->mimoInfo.cwInfo[1].cqi;
29906 #ifdef LTE_TDD      
29907       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
29908 #else      
29909       iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
29910 #endif         
29911    } 
29912
29913    /*ccpu00131191 and ccpu00131317 - Fix for RRC Reconfig failure
29914     * issue for VoLTE call */
29915    //if ((proc->hasDcch)  || (TRUE == rgSCHLaaSCellEnabled(cell)))
29916    if (proc->hasDcch)
29917    {
29918       if (iTbs1 > 5)
29919       {
29920          iTbs1  = iTbs1 - 5;
29921       }
29922       else
29923       {
29924          iTbs1  = 0; 
29925       }
29926       if (iTbs2 > 5)
29927       {
29928          iTbs2  = iTbs2 - 5;
29929       }
29930       else
29931       {
29932          iTbs2  = 0; 
29933       }
29934    }
29935    else if(!cellSch->dl.isDlFreqSel)
29936    {
29937 #ifdef LTE_TDD
29938       /* for Tdd reduce iTbs only for SF0. SF5 contains only 
29939        * SSS and can be ignored */
29940       if (subFrm->sfNum == 0)
29941       {
29942          (iTbs1 > 1)? (iTbs1 -= 1) : (iTbs1 = 0);
29943          (iTbs2 > 1)? (iTbs2 -= 1) : (iTbs2 = 0);
29944       }
29945       /* For SF 3 and 8 CRC is getting failed in DL.
29946          Need to do proper fix after the replay from 
29947          BRCM PHY team*/
29948 #ifdef CA_PHY_BRDCM_61765      
29949       if ((subFrm->sfNum == 3) || (subFrm->sfNum == 8))
29950       {
29951          (iTbs1 > 2)? (iTbs1 -= 2) : (iTbs1 = 0);
29952          (iTbs2 > 2)? (iTbs2 -= 2) : (iTbs2 = 0);
29953       }
29954 #endif
29955 #else
29956 #endif
29957    }
29958
29959 #ifdef LTE_TDD
29960    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
29961    {
29962       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
29963    }
29964 #endif 
29965
29966    eff1 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr1 - 1][cfi]))[iTbs1];
29967    eff2 = (*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[noLyr2 - 1][cfi]))[iTbs2];
29968
29969
29970    bo = RGSCH_MIN(bo,availBits/8);
29971    ueDl->outStndAlloc += bo;
29972    /* consider Cumulative amount of this BO and bytes so far allocated */
29973    bo = RGSCH_MIN(ueDl->outStndAlloc, ueDl->maxTbBits/8);
29974    bo = RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff1)/(eff1+eff2)), 
29975                   ueDl->maxTbSz/8) +
29976         RGSCH_MIN(RGSCH_MAX(RGSCH_CMN_MIN_GRNT_HDR, (bo*eff2)/(eff1+eff2)), 
29977                   (ueDl->maxTbSz)/8) +
29978         1; /* Add 1 to adjust the truncation at weighted averaging */
29979    /* Get the number of REs needed for this bo. */
29980    noRes = ((bo * 8 * 1024) / (eff1 + eff2));
29981
29982    /* Get the number of RBs needed for this transmission */
29983    /* Number of RBs = No of REs / No of REs per RB       */
29984    numRb = RGSCH_CEIL(noRes, cellDl->noResPerRb[cfi]);
29985    /* Cannot exceed the maximum number of RBs per UE */
29986    if (numRb > ueDl->maxRb)
29987    {
29988       numRb = ueDl->maxRb;
29989    }
29990    else
29991    {
29992 #ifdef LTE_ADV
29993       if(RFAILED == rgSCHLaaCmn2CwAdjustPrb(allocInfo,  boTmp, &numRb, ueDl, noLyr1, noLyr2, iTbs1, iTbs2))
29994 #endif
29995       {
29996          while ((numRb <= ueDl->maxRb) &&
29997                (rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1] <= ueDl->maxTbSz) &&
29998                (rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1] <= ueDl->maxTbSz) &&
29999                ((rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8 +
30000                  rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8) <= bo))
30001          {
30002             (numRb)++;
30003          }
30004       }
30005    }
30006    availBw = subFrm->bw - subFrm->bwAssigned;
30007    /* Cannot exceed the total number of RBs in the cell */
30008    if ((S16)(numRb - allocInfo->rbsReq) > availBw)
30009    {
30010       numRb = availBw + allocInfo->rbsReq;
30011    }
30012    tb1Sz = rgTbSzTbl[noLyr1 - 1][iTbs1][numRb-1]/8;
30013    tb2Sz = rgTbSzTbl[noLyr2 - 1][iTbs2][numRb-1]/8;
30014    /* DwPts Scheduling Changes Start */
30015 #ifdef LTE_TDD
30016    if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
30017    { 
30018       /* Max Rb for Special Sf is approximated as 4/3 of maxRb */
30019       rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (U8*)&numRb,  ueDl->maxRb*4/3, 
30020                                 &iTbs1, &iTbs2, noLyr1, 
30021                                 noLyr2, &tb1Sz, &tb2Sz, cfi);   
30022       /* Check for available Bw */
30023       if ((S16)numRb - allocInfo->rbsReq > availBw)
30024       {
30025          numRb = availBw + allocInfo->rbsReq;
30026          tb1Sz = rgTbSzTbl[noLyr1-1][iTbs1][RGSCH_MAX(numRb*3/4,1)-1]/8;
30027          tb2Sz = rgTbSzTbl[noLyr2-1][iTbs2][RGSCH_MAX(numRb*3/4,1)-1]/8;
30028       }
30029    }
30030 #endif
30031    /* DwPts Scheduling Changes End */
30032    /* Update the subframe Allocated BW field */
30033    subFrm->bwAssigned = subFrm->bwAssigned + numRb - \
30034                         allocInfo->rbsReq;
30035
30036    *effBo = RGSCH_MIN((tb1Sz + tb2Sz) - oldReq, reqBytes);
30037
30038 #ifdef LTE_ADV
30039    if (ROK != rgSCHLaaCmn2TBPrbCheck(allocInfo, tb1Sz, tb2Sz, boTmp, effBo, iTbs1, iTbs2, numRb, proc))
30040    {
30041       RETVALUE(RFAILED);
30042    }
30043 #endif
30044
30045    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs1, imcs1);
30046    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs2, imcs2);
30047    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tb1Sz, \
30048          iTbs1, imcs1, &proc->tbInfo[0], noLyr1);
30049    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30050          iTbs2, imcs2, &proc->tbInfo[1], noLyr2);
30051    *numRbRef = (U8)numRb;
30052
30053
30054    RETVALUE(ROK);
30055 }
30056
30057 \f
30058 /**
30059  * @brief This function determines the RBs and Bytes required for
30060  *        Transmission & Retransmission on 2 CWs.
30061  *
30062  * @details
30063  *
30064  *     Function: rgSCHCmnDlAlloc2CwTxRetxRb
30065  *     Purpose:  This function determines the RBs and Bytes required
30066  *               for Transmission & Retransmission on 2 CWs. Allocate
30067  *               RETX TB on a better CW and restrict new TX TB by
30068  *               RETX allocation.
30069  *               Returns RFAILED if BO not satisfied at all.
30070  *
30071  *     Invoked by: TM3 and TM4 DL UE Allocation
30072  *
30073  *  @param[in]  RgSchCellCb      *cell
30074  *  @param[in]  RgSchDlSf        *subFrm
30075  *  @param[in]  RgSchUeCb        *ue
30076  *  @param[in]  RgSchDlHqTbCb    *reTxTb
30077  *  @param[in]  RgSchDlHqTbCb    *txTb
30078  *  @param[out] U8               *numRb
30079  *  @param[out] U32              *effBo
30080  *  @return  Void
30081  *
30082  **/
30083 #ifdef ANSI
30084 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb
30085 (
30086 RgSchCellCb                *cell,
30087 RgSchDlSf                  *subFrm,
30088 RgSchUeCb                  *ue,
30089 RgSchDlHqTbCb              *reTxTb,
30090 RgSchDlHqTbCb              *txTb,
30091 U8                         *numRb,
30092 U32                        *effBo
30093 )
30094 #else
30095 PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
30096         effBo)
30097 RgSchCellCb                *cell;
30098 RgSchDlSf                  *subFrm;
30099 RgSchUeCb                  *ue;
30100 RgSchDlHqTbCb              *reTxTb;
30101 RgSchDlHqTbCb              *txTb;
30102 U8                         *numRb;
30103 U32                        *effBo;
30104 #endif
30105 {
30106    RgSchCmnDlUe       *ueDl;
30107    RgSchDlRbAlloc     *allocInfo;
30108    U8                 imcs1, imcs2;
30109    U8                  noLyr2;
30110    U16                 tb2Sz;
30111    RgSchCmnDlUeCwInfo *otherCw;
30112    S16                 availBw;
30113    RgSchCmnDlCell     *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
30114    U8                 cfi = cellDl->currCfi; 
30115    U8                 iTbs;
30116
30117    TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
30118
30119    ueDl      = RG_SCH_CMN_GET_DL_UE(ue,cell);
30120    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30121    otherCw   = &ueDl->mimoInfo.cwInfo[!(ueDl->mimoInfo.btrCwIdx)];
30122
30123
30124    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30125     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30126     * MCS.  */
30127    availBw = subFrm->bw - subFrm->bwAssigned; 
30128    *numRb = reTxTb->dlGrnt.numRb;
30129
30130 #ifdef XEON_TDD_SPCL
30131    *numRb = (reTxTb->initTxNumRbs);
30132    if(reTxTb->sfType == RG_SCH_SPL_SF_DATA && subFrm->sfType != RG_SCH_SPL_SF_DATA)
30133    {
30134       *numRb = (reTxTb->initTxNumRbs*3/4);
30135
30136       if(*numRb <= 3)
30137       {
30138          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30139          RETVALUE(RFAILED);
30140       }
30141    }
30142 #endif
30143
30144    if ((S16)*numRb > availBw)
30145    {
30146       RETVALUE(RFAILED);
30147    }
30148    /* Update the subframe Allocated BW field */
30149    subFrm->bwAssigned += *numRb;
30150    noLyr2 = otherCw->noLyr;
30151    RG_SCH_CMN_GET_MCS_FOR_RETX(reTxTb, imcs1);
30152
30153    /* If there is no CFI change, continue to use the BLER based
30154     * iTBS value */
30155    if (ueDl->lastCfi == cfi)
30156    {   
30157       iTbs = otherCw->iTbs[noLyr2-1];
30158    }
30159    else
30160    {  
30161 #ifdef LTE_TDD      
30162       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi, 
30163                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30164 #else      
30165       iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi, 
30166                                       !(ueDl->mimoInfo.btrCwIdx), noLyr2);
30167 #endif 
30168    } 
30169    tb2Sz = rgTbSzTbl[noLyr2-1][iTbs][*numRb-1]/8;
30170    /* DwPts Scheduling Changes Start */
30171 #ifdef LTE_TDD
30172 #endif
30173    /* DwPts Scheduling Changes End */
30174    RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, imcs2);
30175    
30176    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], reTxTb->tbSz, \
30177                               0, imcs1, reTxTb, reTxTb->numLyrs);
30178    
30179    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
30180                               iTbs, imcs2, txTb, noLyr2);
30181    
30182    *effBo = reTxTb->tbSz + tb2Sz;
30183
30184    RETVALUE(ROK);
30185 }
30186
30187 \f
30188 /**
30189  * @brief This function determines the RBs and Bytes required for BO
30190  *        Retransmission on 2 CWs.
30191  *
30192  * @details
30193  *
30194  *     Function: rgSCHCmnDlAlloc2CwRetxRb
30195  *     Purpose:  This function determines the RBs and Bytes required
30196  *               for BO Retransmission on 2 CWs. Allocate larger TB
30197  *               on a better CW and check if the smaller TB can be
30198  *               accomodated on the other CW.
30199  *               Returns RFAILED if BO not satisfied at all.
30200  *
30201  *     Invoked by: Common Scheduler
30202  *
30203  *  @param[in]  RgSchCellCb      *cell
30204  *  @param[in]  RgSchDlSf        *subFrm
30205  *  @param[in]  RgSchUeCb        *ue
30206  *  @param[in]  RgSchDlHqProcCb  *proc
30207  *  @param[out] U8               *numRb
30208  *  @param[out] Bool             *swpFlg
30209  *  @param[out] U32              *effBo
30210  *  @return  Void
30211  *
30212  **/
30213 #ifdef ANSI
30214 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb
30215 (
30216 RgSchCellCb                *cell,
30217 RgSchDlSf                  *subFrm,
30218 RgSchUeCb                  *ue,
30219 RgSchDlHqProcCb            *proc,
30220 U8                         *numRb,
30221 Bool                       *swpFlg,
30222 U32                        *effBo
30223 )
30224 #else
30225 PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
30226         numRb, swpFlg, effBo)
30227 RgSchCellCb                *cell;
30228 RgSchDlSf                  *subFrm;
30229 RgSchUeCb                  *ue;
30230 RgSchDlHqProcCb            *proc;
30231 U8                         *numRb;
30232 Bool                       *swpFlg;
30233 U32                        *effBo;
30234 #endif
30235 {
30236    RgSchDlRbAlloc     *allocInfo;
30237    U8                 imcs1;
30238    U8                 imcs2;
30239    RgSchDlHqTbCb      *lrgTbInfo, *othrTbInfo;
30240
30241    TRC2(rgSCHCmnDlAlloc2CwRetxRb);
30242
30243    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30244
30245
30246    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30247     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30248     * MCS.  */
30249    lrgTbInfo  = &proc->tbInfo[0];
30250    othrTbInfo = &proc->tbInfo[1];
30251    *numRb = lrgTbInfo->dlGrnt.numRb;
30252 #ifdef XEON_TDD_SPCL
30253    if((lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA || othrTbInfo->sfType == RG_SCH_SPL_SF_DATA))
30254    {
30255       if(lrgTbInfo->sfType == RG_SCH_SPL_SF_DATA)
30256       {       
30257           *numRb = (lrgTbInfo->initTxNumRbs);
30258       }
30259       else
30260       {
30261           *numRb = (othrTbInfo->initTxNumRbs);
30262       }
30263
30264       if(subFrm->sfType != RG_SCH_SPL_SF_DATA)
30265       {
30266          *numRb = (*numRb)*3/4;
30267       }
30268        
30269       if(*numRb <= 3)
30270       {
30271          RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
30272          RETVALUE(RFAILED);
30273       }
30274    }
30275 #endif
30276    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30277    {
30278       RETVALUE(RFAILED);
30279    }
30280    /* Update the subframe Allocated BW field */
30281    subFrm->bwAssigned += *numRb;
30282    RG_SCH_CMN_GET_MCS_FOR_RETX(lrgTbInfo, imcs1);
30283    RG_SCH_CMN_GET_MCS_FOR_RETX(othrTbInfo, imcs2);
30284    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], lrgTbInfo->tbSz, \
30285          0, imcs1, lrgTbInfo, lrgTbInfo->numLyrs);
30286    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], othrTbInfo->tbSz, \
30287          0, imcs2, othrTbInfo, othrTbInfo->numLyrs);
30288    *effBo = lrgTbInfo->tbSz + othrTbInfo->tbSz;
30289
30290
30291
30292    RETVALUE(ROK);
30293 }
30294
30295 \f
30296 /**
30297  * @brief This function determines the RBs and Bytes required for BO
30298  *        Retransmission on 1 CW.
30299  *
30300  * @details
30301  *
30302  *     Function: rgSCHCmnDlAlloc1CwRetxRb
30303  *     Purpose:  This function determines the RBs and Bytes required
30304  *               for BO Retransmission on 1 CW, the first CW.
30305  *               Returns RFAILED if BO not satisfied at all.
30306  *
30307  *     Invoked by: Common Scheduler
30308  *
30309  *  @param[in]  RgSchCellCb      *cell
30310  *  @param[in]  RgSchDlSf        *subFrm
30311  *  @param[in]  RgSchUeCb        *ue
30312  *  @param[in]  RgSchDlHqTbCb    *tbInfo
30313  *  @param[in]  U8               noLyr
30314  *  @param[out] U8               *numRb
30315  *  @param[out] U32              *effBo
30316  *  @return  S16
30317  *
30318  **/
30319 #ifdef ANSI
30320 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb
30321 (
30322 RgSchCellCb                *cell,
30323 RgSchDlSf                  *subFrm,
30324 RgSchUeCb                  *ue,
30325 RgSchDlHqTbCb              *tbInfo,
30326 U8                         noLyr,
30327 U8                         *numRb,
30328 U32                        *effBo
30329 )
30330 #else
30331 PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
30332         numRb, effBo)
30333 RgSchCellCb                *cell;
30334 RgSchDlSf                  *subFrm;
30335 RgSchUeCb                  *ue;
30336 RgSchDlHqTbCb              *tbInfo;
30337 U8                         noLyr;
30338 U8                         *numRb;
30339 U32                        *effBo;
30340 #endif
30341 {
30342    RgSchDlRbAlloc  *allocInfo;
30343    U8              imcs;
30344
30345    TRC2(rgSCHCmnDlAlloc1CwRetxRb);
30346
30347    allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
30348
30349
30350    /* Fix for ccpu00123919: In case of RETX TB scheduling avoiding recomputation of RB
30351     * and Tbs. Set all parameters same as Init TX except RV(only for NACKED) and
30352     * MCS.  */
30353    *numRb = tbInfo->dlGrnt.numRb;
30354    if ((S16)*numRb > (S16)(subFrm->bw - subFrm->bwAssigned))
30355    {
30356       RETVALUE(RFAILED);
30357    }
30358    /* Update the subframe Allocated BW field */
30359    subFrm->bwAssigned += *numRb;
30360    imcs = tbInfo->dlGrnt.iMcs;
30361    allocInfo->dciFormat = tbInfo->dlGrnt.dciFormat; 
30362    /* Fix: For a RETX TB the iTbs is irrelevant, hence setting 0 */
30363    RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbInfo->tbSz, \
30364          0, imcs, tbInfo, tbInfo->numLyrs);
30365    *effBo = tbInfo->tbSz;
30366
30367    RETVALUE(ROK);
30368 }
30369
30370 #ifdef LTEMAC_SPS
30371
30372 /**
30373  * @brief This function is called to handle Release PDCCH feedback for SPS UE
30374  *
30375  * @details
30376  *
30377  *     Function: rgSCHCmnDlRelPdcchFbk
30378  *     Purpose:  Invokes SPS module to handle release PDCCH feedback
30379  *
30380  *     Invoked by: DHM
30381  *
30382  *  @param[in]   RgSchCellCb     *cell
30383  *  @param[in]   RgSchUeCb       *ue
30384  *  @param[in]   Bool            isAck
30385  *  @return  Void
30386  *
30387  **/
30388 #ifdef ANSI
30389 PUBLIC Void rgSCHCmnDlRelPdcchFbk
30390 (
30391 RgSchCellCb        *cell,
30392 RgSchUeCb          *ue,
30393 Bool               isAck
30394 )
30395 #else
30396 PUBLIC Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
30397 RgSchCellCb        *cell;
30398 RgSchUeCb          *ue;
30399 Bool               isAck;
30400 #endif
30401 {
30402
30403    TRC2(rgSCHCmnDlRelPdcchFbk);
30404    rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
30405    RETVOID;
30406
30407 }
30408
30409
30410 /**
30411  * @brief This function is invoked to handle Ack processing for a HARQ proc.
30412  *
30413  * @details
30414  *
30415  *     Function: rgSCHCmnDlProcAck
30416  *     Purpose:  DTX processing for HARQ proc
30417  *
30418  *     Invoked by: DHM
30419  *
30420  *  @param[in]   RgSchCellCb     *cell
30421  *  @param[in]   RgSchDlHqProcCb *hqP
30422  *  @return  Void
30423  *
30424  **/
30425 #ifdef ANSI
30426 PUBLIC Void rgSCHCmnDlProcAck
30427 (
30428 RgSchCellCb        *cell,
30429 RgSchDlHqProcCb    *hqP
30430 )
30431 #else
30432 PUBLIC Void rgSCHCmnDlProcAck(cell, hqP)
30433 RgSchCellCb        *cell;
30434 RgSchDlHqProcCb    *hqP;
30435 #endif
30436 {
30437
30438    TRC2(rgSCHCmnDlProcAck);
30439
30440    if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
30441    {
30442       /* Invoke SPS module if SPS service was scheduled for this HARQ proc */
30443       rgSCHCmnSpsDlProcAck(cell, hqP);
30444    }
30445    RETVOID;
30446 }
30447 #ifdef RGSCH_SPS_STATS
30448 extern U32 rgSchStatCrntiCeRcvCnt;
30449 #endif
30450 /**
30451  * @brief This function is invoked to handle CRNTI CE reception for an UE
30452  *
30453  * @details
30454  *
30455  *     Function: rgSCHCmnHdlCrntiCE
30456  *     Purpose:  Handle CRNTI CE reception
30457  *
30458  *     Invoked by: DHM
30459  *
30460  *  @param[in]   RgSchCellCb     *cell
30461  *  @param[in]   RgSchDlHqProcCb *hqP
30462  *  @return  Void
30463  *
30464  **/
30465 #ifdef ANSI
30466 PUBLIC Void rgSCHCmnHdlCrntiCE
30467 (
30468 RgSchCellCb        *cell,
30469 RgSchUeCb          *ue
30470 )
30471 #else
30472 PUBLIC Void rgSCHCmnHdlCrntiCE(cell, ue)
30473 RgSchCellCb        *cell;
30474 RgSchUeCb          *ue;
30475 #endif
30476 {
30477
30478    TRC2(rgSCHCmnHdlCrntiCE);
30479 #ifdef RGSCH_SPS_STATS   
30480    rgSchStatCrntiCeRcvCnt++;
30481 #endif
30482
30483    /* When UL sync lost happened due to TA timer expiry UE is being moved to 
30484       PDCCH order inactivity list.But when CRNTI CE received in msg3 from UE
30485       we are not moving UE into active state due to that RRC Reconfiguration is
30486       not happening.
30487       So here we are moving UE to active list whenever we receive the CRNTI CE and
30488       UE is inactive */
30489    /* CR ccpu00144525 */      
30490    if (RG_SCH_CMN_IS_UE_PDCCHODR_INACTV(ue))
30491    {
30492        /* Activate this UE if it was inactive */
30493        RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30494        RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
30495    }
30496
30497    /* Handling is same as reception of UE RESET for both DL and UL */
30498    if (ue->dl.dlSpsCfg.isDlSpsEnabled)
30499    {
30500       rgSCHCmnSpsDlUeReset(cell, ue);
30501    }
30502    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30503    {
30504       rgSCHCmnSpsUlUeReset(cell, ue);
30505    }
30506    
30507    RETVOID;
30508 }
30509
30510
30511 /**
30512  * @brief This function is called to handle relInd from MAC for a UE
30513  *
30514  * @details
30515  *
30516  *     Function: rgSCHCmnUlSpsRelInd
30517  *     Purpose:  Invokes SPS module to handle UL SPS release for a UE
30518  *
30519  *     Invoked by: SCH_UTL
30520  *
30521  *  @param[in]   RgSchCellCb        *cell
30522  *  @param[in]   RgSchUeCb          *ue
30523  *  @param[in]   Bool               isExplRel
30524  *  @return  Void
30525  *
30526  **/
30527 #ifdef ANSI
30528 PUBLIC Void rgSCHCmnUlSpsRelInd
30529 (
30530 RgSchCellCb        *cell,
30531 RgSchUeCb          *ue,
30532 Bool               isExplRel
30533 )
30534 #else
30535 PUBLIC Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
30536 RgSchCellCb        *cell;
30537 RgSchUeCb          *ue;
30538 Bool               isExplRel;
30539 #endif
30540 {
30541
30542    TRC2(rgSCHCmnUlSpsRelInd);
30543    rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
30544    RETVOID;
30545
30546 } /* end of rgSCHCmnUlSpsRelInd */
30547
30548 /**
30549  * @brief This function is called to handle SPS Activate Ind from MAC for a UE
30550  *
30551  * @details
30552  *
30553  *     Function: rgSCHCmnUlSpsActInd
30554  *     Purpose:  Invokes SPS module to handle UL SPS activate for a UE
30555  *
30556  *     Invoked by: SCH_UTL
30557  *
30558  *  @param[in]   RgSchCellCb        *cell
30559  *  @param[in]   RgSchUeCb          *ue
30560  *  @return  Void
30561  *
30562  **/
30563 #ifdef ANSI
30564 PUBLIC Void rgSCHCmnUlSpsActInd
30565 (
30566 RgSchCellCb        *cell,
30567 RgSchUeCb          *ue,
30568 U16                spsSduSize
30569 )
30570 #else
30571 PUBLIC Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
30572 RgSchCellCb        *cell;
30573 RgSchUeCb          *ue;
30574 U16                spsSduSize;
30575 #endif
30576 {
30577
30578    TRC2(rgSCHCmnUlSpsActInd);
30579
30580    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30581    {
30582       rgSCHCmnSpsUlProcActInd(cell, ue,spsSduSize);
30583    }
30584    RETVOID;
30585
30586 } /* end of rgSCHCmnUlSpsActInd */
30587
30588 /**
30589  * @brief This function is called to handle CRC in UL for UEs
30590  * undergoing SPS release
30591  *
30592  * @details
30593  *
30594  *     Function: rgSCHCmnUlCrcInd
30595  *     Purpose:  Invokes SPS module to handle CRC in UL for SPS UE
30596  *
30597  *     Invoked by: SCH_UTL
30598  *
30599  *  @param[in]   RgSchCellCb        *cell
30600  *  @param[in]   RgSchUeCb          *ue
30601  *  @param[in]   CmLteTimingInfo    crcTime
30602  *  @return  Void
30603  *
30604  **/
30605 #ifdef ANSI
30606 PUBLIC Void rgSCHCmnUlCrcInd
30607 (
30608 RgSchCellCb        *cell,
30609 RgSchUeCb          *ue,
30610 CmLteTimingInfo    crcTime
30611 )
30612 #else
30613 PUBLIC Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
30614 RgSchCellCb        *cell;
30615 RgSchUeCb          *ue;
30616 CmLteTimingInfo    crcTime;
30617 #endif
30618 {
30619
30620    TRC2(rgSCHCmnUlCrcInd);
30621    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30622    {
30623       rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
30624    }
30625    RETVOID;
30626
30627 } /* end of rgSCHCmnUlCrcFailInd */
30628
30629 /**
30630  * @brief This function is called to handle CRC failure in UL
30631  *
30632  * @details
30633  *
30634  *     Function: rgSCHCmnUlCrcFailInd
30635  *     Purpose:  Invokes SPS module to handle CRC failure in UL for SPS UE
30636  *
30637  *     Invoked by: SCH_UTL
30638  *
30639  *  @param[in]   RgSchCellCb        *cell
30640  *  @param[in]   RgSchUeCb          *ue
30641  *  @param[in]   CmLteTimingInfo    crcTime
30642  *  @return  Void
30643  *
30644  **/
30645 #ifdef ANSI
30646 PUBLIC Void rgSCHCmnUlCrcFailInd
30647 (
30648 RgSchCellCb        *cell,
30649 RgSchUeCb          *ue,
30650 CmLteTimingInfo    crcTime
30651 )
30652 #else
30653 PUBLIC Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
30654 RgSchCellCb        *cell;
30655 RgSchUeCb          *ue;
30656 CmLteTimingInfo    crcTime;
30657 #endif
30658 {
30659
30660    TRC2(rgSCHCmnUlCrcFailInd);
30661    if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
30662    {
30663       rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
30664    }
30665    RETVOID;
30666
30667 } /* end of rgSCHCmnUlCrcFailInd */
30668
30669 #endif /* LTEMAC_SPS */
30670
30671 /**
30672  * @brief BCH,BCCH,PCCH Dowlink Scheduling Handler.
30673  *
30674  * @details
30675  *
30676  *     Function: rgSCHCmnDlBcchPcchAlloc
30677  *     Purpose:  This function calls common scheduler APIs to
30678  *     schedule for BCCH/PCCH.
30679  *     It then invokes Allocator for actual RB
30680  *     allocations. It processes on the actual resources allocated
30681  *     against requested to the allocator module.
30682  *
30683  *     Invoked by: Common Scheduler
30684  *
30685  *  @param[in]  RgSchCellCb *cell
30686  *  @return  Void
30687  **/
30688 #ifdef ANSI
30689 PRIVATE Void rgSCHCmnDlBcchPcchAlloc
30690 (
30691 RgSchCellCb  *cell
30692 )
30693 #else
30694 PRIVATE Void rgSCHCmnDlBcchPcchAlloc(cell)
30695 RgSchCellCb  *cell;
30696 #endif
30697 {
30698 #ifdef LTE_TDD
30699    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
30700 #else
30701 #ifdef LTEMAC_HDFDD
30702    U8           nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
30703 #else
30704    U8           nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
30705 #endif
30706 #endif
30707    RgInfSfAlloc *nextsfAlloc = &(cell->sfAllocArr[nextSfIdx]);
30708    RgSchCmnCell           *cellSch   = RG_SCH_CMN_GET_CELL(cell);
30709    RgSchCmnDlRbAllocInfo  *allocInfo = &cellSch->allocInfo;  
30710    
30711    TRC2(rgSCHCmnDlBcchPcchAlloc);
30712
30713
30714    /*Reset the bitmask for BCCH/PCCH*/
30715    rgSCHUtlResetSfAlloc(nextsfAlloc,TRUE,FALSE);
30716 #ifndef DISABLE_MIB_SIB /* Not sending MIB and SIB to CL */
30717 #ifdef RGR_SI_SCH
30718    rgSCHChkNUpdSiCfg(cell);
30719    rgSCHSelectSi(cell);
30720 #endif
30721
30722    /*Perform the scheduling for BCCH,PCCH*/
30723    rgSCHCmnDlBcchPcch(cell, allocInfo, nextsfAlloc);
30724
30725    /* Call common allocator for RB Allocation */
30726    rgSCHBcchPcchDlRbAlloc(cell, allocInfo);
30727
30728    /* Finalize the Allocations for reqested Against alloced */
30729    rgSCHCmnDlBcchPcchFnlz(cell, allocInfo);
30730 #endif /* DISABLE_MIB_SIB */
30731    RETVOID;
30732 }
30733
30734 /**
30735  * @brief Handles RB allocation for BCCH/PCCH for downlink.
30736  *
30737  * @details
30738  *
30739  *     Function : rgSCHBcchPcchDlRbAlloc
30740  *
30741  *     Invoking Module Processing:
30742  *     - This function is invoked for DL RB allocation of BCCH/PCCH
30743  *
30744  *     Processing Steps:
30745  *     - If cell is frequency selecive,
30746  *       - Call rgSCHDlfsBcchPcchAllocRb().
30747  *     - else,
30748  *       - Do the processing
30749  *
30750  *  @param[in]  RgSchCellCb        *cell
30751  *  @param[in]  RgSchDlRbAllocInfo *allocInfo
30752  *  @return  Void
30753  **/
30754
30755 #ifdef ANSI
30756 PRIVATE Void rgSCHBcchPcchDlRbAlloc
30757 (
30758 RgSchCellCb           *cell,
30759 RgSchCmnDlRbAllocInfo *allocInfo
30760 )
30761 #else
30762 PRIVATE Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
30763 RgSchCellCb           *cell;
30764 RgSchCmnDlRbAllocInfo *allocInfo;
30765 #endif
30766 {
30767    RgSchCmnCell      *cellSch = RG_SCH_CMN_GET_CELL(cell);
30768
30769    TRC2(rgSCHBcchPcchDlRbAlloc);
30770
30771
30772    if (cellSch->dl.isDlFreqSel)
30773    {
30774       cellSch->apisDlfs->rgSCHDlfsBcchPcchAllocRb(cell, allocInfo);
30775    }
30776    else
30777    {
30778       rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo);
30779    }
30780
30781    RETVOID;
30782 }
30783
30784 /**
30785  * @brief Handles RB allocation for BCCH,PCCH for frequency
30786  *  non-selective cell.
30787  *
30788  * @details
30789  *
30790  *     Function : rgSCHCmnNonDlfsBcchPcchRbAlloc
30791  *
30792  *     Invoking Module Processing:
30793  *      - SCH shall invoke this if downlink frequency selective is disabled for
30794  *        the cell for RB allocation.
30795  *      - MAX C/I/PFS/RR shall provide the requiredBytes, required RBs
30796  *        estimate and subframe for each allocation to be made to SCH.
30797  *
30798  *     Processing Steps:
30799  *     - Allocate sequentially for BCCH,PCCH common channels.
30800  *
30801  *  @param[in]  RgSchCellCb        *cell
30802  *  @param[in]  RgSchCmnDlRbAllocInfo *allocInfo
30803  *  @return  Void
30804  **/
30805
30806 #ifdef ANSI
30807 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc
30808 (
30809 RgSchCellCb           *cell,
30810 RgSchCmnDlRbAllocInfo *allocInfo
30811 )
30812 #else
30813 PRIVATE Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
30814 RgSchCellCb           *cell;
30815 RgSchCmnDlRbAllocInfo *allocInfo;
30816 #endif
30817 {
30818    RgSchDlRbAlloc     *reqAllocInfo;
30819
30820    TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
30821
30822    /* 143473 */
30823    /* Allocate for PCCH */
30824    reqAllocInfo = &(allocInfo->pcchAlloc);
30825    if (reqAllocInfo->rbsReq)
30826    {
30827       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30828    }
30829    /* Allocate for BCCH on DLSCH */
30830    reqAllocInfo = &(allocInfo->bcchAlloc);
30831    if (reqAllocInfo->rbsReq)
30832    {
30833       rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
30834    }
30835    RETVOID;
30836 }
30837
30838
30839 #ifdef RGR_SI_SCH
30840 /**
30841  * @brief This function implements the handling to check and
30842  *        update the SI cfg at the start of the modificiation period.
30843  *
30844  * @details
30845  *
30846  *     Function: rgSCHChkNUpdSiCfg
30847  *     Purpose:  This function implements handling for update of SI Cfg
30848  *               at the start of modification period.
30849  *
30850  *     Invoked by: Scheduler
30851  *
30852  *  @param[in]  RgSchCellCb*     cell
30853  *  @return  S16
30854  *      -# ROK
30855  *      -# RFAILED
30856  **/
30857 #ifdef ANSI
30858 PRIVATE Void rgSCHChkNUpdSiCfg
30859 (
30860 RgSchCellCb             *cell
30861 )
30862 #else
30863 PRIVATE Void rgSCHChkNUpdSiCfg(cell)
30864 RgSchCellCb             *cell;
30865 #endif
30866 {
30867    CmLteTimingInfo   pdSchTmInfo;
30868
30869    TRC2(rgSCHChkNUpdSiCfg);
30870
30871
30872    pdSchTmInfo   = cell->crntTime;
30873 #ifdef LTEMAC_HDFDD
30874    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
30875       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
30876    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
30877 #else
30878    RGSCH_INCR_SUB_FRAME(pdSchTmInfo, RG_SCH_CMN_DL_DELTA);
30879 #endif
30880
30881
30882    /* Updating the SIB1 for Warning SI message immediately after it is received 
30883     * from application. No need to wait for next modification period.
30884     */
30885    if((pdSchTmInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
30886          && (RGSCH_SIB1_TX_SF_NUM == (pdSchTmInfo.slot % RGSCH_NUM_SUB_FRAMES)))
30887    {   
30888       /*Check whether SIB1 with PWS has been updated*/
30889       if(cell->siCb.siBitMask & RGSCH_SI_SIB1_PWS_UPD)
30890       {
30891          RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30892                cell->siCb.newSiInfo.sib1Info.sib1);
30893          cell->siCb.crntSiInfo.sib1Info.mcs = 
30894             cell->siCb.newSiInfo.sib1Info.mcs;
30895          cell->siCb.crntSiInfo.sib1Info.nPrb = 
30896              cell->siCb.newSiInfo.sib1Info.nPrb;
30897          cell->siCb.crntSiInfo.sib1Info.msgLen = 
30898             cell->siCb.newSiInfo.sib1Info.msgLen;
30899          cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_PWS_UPD;
30900       }
30901    }
30902
30903    /*Check if this SFN and SF No marks the start of next modification
30904      period. If current SFN,SF No doesn't marks the start of next
30905      modification period, then return. */
30906    if(!((pdSchTmInfo.sfn % cell->siCfg.modPrd == 0)
30907             && (0 == pdSchTmInfo.slot)))
30908    /*if(!((((pdSchTmInfo.hSfn * 1024) + pdSchTmInfo.sfn) % cell->siCfg.modPrd == 0)
30909             && (0 == pdSchTmInfo.slot)))*/
30910    {
30911       RETVOID;
30912    }
30913
30914    /*Check whether MIB has been updated*/
30915    if(cell->siCb.siBitMask & RGSCH_SI_MIB_UPD)
30916    {
30917       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.mib,
30918             cell->siCb.newSiInfo.mib);
30919       cell->siCb.siBitMask &= ~RGSCH_SI_MIB_UPD;
30920    }
30921
30922    /*Check whether SIB1 has been updated*/
30923    if(cell->siCb.siBitMask & RGSCH_SI_SIB1_UPD)
30924    {
30925       RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.sib1Info.sib1,
30926             cell->siCb.newSiInfo.sib1Info.sib1);
30927       cell->siCb.crntSiInfo.sib1Info.mcs = cell->siCb.newSiInfo.sib1Info.mcs;
30928       cell->siCb.crntSiInfo.sib1Info.nPrb = cell->siCb.newSiInfo.sib1Info.nPrb;
30929       cell->siCb.crntSiInfo.sib1Info.msgLen = 
30930          cell->siCb.newSiInfo.sib1Info.msgLen;
30931       cell->siCb.siBitMask &= ~RGSCH_SI_SIB1_UPD;
30932    }
30933
30934    /*Check whether SIs have been updated*/
30935    if(cell->siCb.siBitMask & RGSCH_SI_SI_UPD)
30936    {
30937       U8  idx;
30938
30939       /*Check if SI cfg have been modified And Check if numSi have
30940         been changed, if yes then we would need to update the
30941         pointers for all the SIs */
30942       if((cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD) &&
30943             (cell->siCfg.numSi != cell->siCb.newSiCfg.numSi))
30944       {
30945          for(idx = 0;idx < cell->siCb.newSiCfg.numSi;idx++)
30946          {
30947             RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
30948                   cell->siCb.newSiInfo.siInfo[idx].si);
30949             cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
30950             cell->siCb.siArray[idx].isWarningSi = FALSE;
30951
30952             cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
30953             cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
30954             cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
30955          }
30956
30957          /*If numSi have been reduced then we need to free the
30958            pointers at the indexes in crntSiInfo which haven't
30959            been exercised. If numSi has increased then nothing
30960            additional is requires as above handling has taken
30961            care.*/
30962          if(cell->siCfg.numSi > cell->siCb.newSiCfg.numSi)
30963          {
30964             for(idx = cell->siCb.newSiCfg.numSi;
30965                   idx < cell->siCfg.numSi;idx++)
30966             {
30967                RGSCH_FREE_MSG(cell->siCb.crntSiInfo.siInfo[idx].si);
30968                cell->siCb.siArray[idx].si = NULLP;
30969             }
30970          }
30971       }
30972       else
30973       {
30974          /*numSi has not been updated, we just need to update the
30975            pointers for the SIs which are set to NON NULLP */
30976          /*ccpu00118260 - Correct Update of SIB2 */
30977          for(idx = 0;idx < cell->siCfg.numSi;idx++)
30978          {
30979             if(NULLP != cell->siCb.newSiInfo.siInfo[idx].si)
30980             {
30981                RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[idx].si,
30982                      cell->siCb.newSiInfo.siInfo[idx].si);
30983
30984                cell->siCb.siArray[idx].si = cell->siCb.crntSiInfo.siInfo[idx].si;
30985                cell->siCb.siArray[idx].isWarningSi = FALSE;
30986                cell->siCb.crntSiInfo.siInfo[idx].mcs = cell->siCb.newSiInfo.siInfo[idx].mcs;
30987                cell->siCb.crntSiInfo.siInfo[idx].nPrb = cell->siCb.newSiInfo.siInfo[idx].nPrb;
30988                cell->siCb.crntSiInfo.siInfo[idx].msgLen = cell->siCb.newSiInfo.siInfo[idx].msgLen;
30989             }
30990          }
30991       }
30992       cell->siCb.siBitMask &= ~RGSCH_SI_SI_UPD;
30993    }
30994
30995    /*Check whether SI cfg have been updated*/
30996    if(cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
30997    {
30998       cell->siCfg = cell->siCb.newSiCfg;
30999       cell->siCb.siBitMask &= ~RGSCH_SI_SICFG_UPD;
31000    }
31001
31002    RETVOID;
31003 }
31004
31005
31006 /**
31007  * @brief This function implements the selection of the SI
31008  *        that is to be scheduled.
31009  *
31010  * @details
31011  *
31012  *     Function: rgSCHSelectSi
31013  *     Purpose:  This function implements the selection of SI
31014  *               that is to be scheduled.
31015  *
31016  *     Invoked by: Scheduler
31017  *
31018  *  @param[in]  RgSchCellCb*     cell
31019  *  @return  S16
31020  *      -# ROK
31021  *      -# RFAILED
31022  **/
31023 #ifdef ANSI
31024 PRIVATE Void rgSCHSelectSi
31025 (
31026 RgSchCellCb             *cell
31027 )
31028 #else
31029 PRIVATE Void rgSCHSelectSi(cell)
31030 RgSchCellCb             *cell;
31031 #endif
31032 {
31033    CmLteTimingInfo        crntTmInfo;
31034    U8                     siWinSize;
31035    U16                    x; 
31036    U16                    windowId; 
31037
31038    TRC2(rgSCHSelectSi);
31039
31040
31041    crntTmInfo  = cell->crntTime;
31042 #ifdef LTEMAC_HDFDD
31043    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31044       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31045    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31046 #else
31047    RGSCH_INCR_SUB_FRAME(crntTmInfo, RG_SCH_CMN_DL_DELTA);
31048 #endif
31049
31050    siWinSize    = cell->siCfg.siWinSize;
31051
31052    /* Select SI only once at the starting of the new window */
31053    if(cell->siCb.inWindow)
31054    {
31055       if ((crntTmInfo.sfn % cell->siCfg.minPeriodicity) == 0 && 
31056           crntTmInfo.slot == 0)
31057       {
31058          /* Reinit inWindow at the beginning of every SI window */
31059          cell->siCb.inWindow = siWinSize - 1;
31060       }
31061       else
31062       {
31063          cell->siCb.inWindow--;
31064          RETVOID;
31065       }
31066    }
31067    else /* New window. Re-init the winSize counter with the window length */
31068    {
31069       if((cell->siCb.siArray[cell->siCb.siCtx.siId - 1].isWarningSi == TRUE)&&
31070             (cell->siCb.siCtx.retxCntRem != 0))   
31071       {
31072          rgSCHUtlFreeWarningSiPdu(cell);
31073          cell->siCb.siCtx.warningSiFlag  = FALSE;
31074       }
31075
31076       cell->siCb.inWindow = siWinSize - 1;
31077    }
31078
31079    x = rgSCHCmnGetSiSetId(crntTmInfo.sfn, crntTmInfo.slot, 
31080                                   cell->siCfg.minPeriodicity); 
31081
31082    /* Window Id within a SI set. This window Id directly maps to a
31083     * unique SI Id */
31084    windowId = (((crntTmInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + 
31085             crntTmInfo.slot) - (x * (cell->siCfg.minPeriodicity * 10))) 
31086                                                                / siWinSize;
31087
31088    if(windowId >= RGR_MAX_NUM_SI)
31089       RETVOID;
31090
31091    /* Update the siCtx if there is a valid SI and its periodicity
31092     * has occurred */
31093    if (NULLP != cell->siCb.siArray[windowId].si)
31094    {
31095       /* Warning SI Periodicity is same as SIB2 Periodicity */
31096       if(((cell->siCb.siArray[windowId].isWarningSi == FALSE) && 
31097                (x % (cell->siCfg.siPeriodicity[windowId]
31098                      /cell->siCfg.minPeriodicity) == 0)) || 
31099             ((cell->siCb.siArray[windowId].isWarningSi == TRUE) &&
31100              (x % (cell->siCfg.siPeriodicity[0]
31101                    /cell->siCfg.minPeriodicity) == 0)))
31102       {
31103          cell->siCb.siCtx.siId = windowId+1;
31104          cell->siCb.siCtx.retxCntRem = cell->siCfg.retxCnt;
31105          cell->siCb.siCtx.warningSiFlag = cell->siCb.siArray[windowId].
31106                                                            isWarningSi;
31107          cell->siCb.siCtx.timeToTx.sfn = crntTmInfo.sfn;
31108          cell->siCb.siCtx.timeToTx.slot = crntTmInfo.slot;
31109
31110          RG_SCH_ADD_TO_CRNT_TIME(cell->siCb.siCtx.timeToTx,
31111                cell->siCb.siCtx.maxTimeToTx, (siWinSize - 1))
31112       }
31113    }
31114    else
31115    {/* Update the siCtx with invalid si Id */
31116       cell->siCb.siCtx.siId = 0;
31117    }
31118
31119    RETVOID;
31120 }
31121
31122
31123 /**
31124  * @brief This function implements scheduler DL allocation for
31125  *        SI.
31126  *
31127  * @details
31128  *
31129  *     Function: rgSCHDlSiSched
31130  *     Purpose:  This function implements scheduler for DL allocation
31131  *               for SI.
31132  *
31133  *     Invoked by: Scheduler
31134  *
31135  *  @param[in]  RgSchCellCb*     cell
31136  *  @return  S16
31137  *      -# ROK
31138  *      -# RFAILED
31139  **/
31140 #ifdef ANSI
31141 PRIVATE Void rgSCHDlSiSched
31142 (
31143 RgSchCellCb             *cell,
31144 RgSchCmnDlRbAllocInfo   *allocInfo,
31145 RgInfSfAlloc            *subfrmAlloc
31146 )
31147 #else
31148 PRIVATE Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
31149 RgSchCellCb             *cell;
31150 RgSchCmnDlRbAllocInfo   *allocInfo;
31151 RgInfSfAlloc            *subfrmAlloc;
31152 #endif
31153 {
31154    CmLteTimingInfo   crntTimInfo;
31155    RgSchDlSf         *sf;
31156    U8                nPrb = 0;
31157    U8                mcs  = 0;
31158    MsgLen            msgLen = 0;
31159    U32               rb=0;
31160    RgSchCmnDlCell    *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
31161    /* DwPTS Scheduling Changes Start */
31162 #ifdef LTE_TDD   
31163    U16                lostRe;  
31164    U8                 cfi = cellDl->currCfi;      
31165 #endif
31166    /* DwPTS Scheduling Changes End */
31167
31168    TRC2(rgSCHDlSiSched);
31169
31170
31171    crntTimInfo   = cell->crntTime;
31172 #ifdef LTEMAC_HDFDD
31173    /* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
31174       + RG_SCH_CMN_HARQ_INTERVAL (7) subframes ahead */
31175    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA + RG_SCH_CMN_HARQ_INTERVAL);
31176 #else
31177    RGSCH_INCR_SUB_FRAME(crntTimInfo, RG_SCH_CMN_DL_DELTA);
31178 #endif
31179
31180    /* Compute the subframe for which allocation is being made.
31181       Essentially, we need pointer to the dl frame for this subframe */
31182    sf = rgSCHUtlSubFrmGet(cell, crntTimInfo);
31183
31184    /*Check if scheduling of MIB is required */
31185 #ifdef EMTC_ENABLE
31186    /* since we are adding the MIB repetition logic for EMTC UEs, checking if
31187     * emtcEnabled or not,  If enabled MIB would be repeted at as part of EMTC
31188     * feature, otherwise scheduling at (n,0) */
31189    if(0 == cell->emtcEnable)
31190    {
31191 #endif
31192    if((crntTimInfo.sfn % RGSCH_MIB_PERIODICITY == 0)
31193          && (RGSCH_MIB_TX_SF_NUM == crntTimInfo.slot))
31194    {
31195       MsgLen  mibLen = 0;
31196       U8      sfnOctet, mibOct2 = 0;
31197       U8      mibOct1 = 0;
31198       /*If MIB has not been yet setup by Application, return*/
31199       if(NULLP == cell->siCb.crntSiInfo.mib)
31200          RETVOID;
31201
31202       SFndLenMsg(cell->siCb.crntSiInfo.mib, &mibLen);
31203       sf->bch.tbSize = mibLen;
31204       /*Fill the interface information */
31205       rgSCHUtlFillRgInfCmnLcInfo(sf, subfrmAlloc, NULLD, NULLD);
31206
31207       /*Set the bits of MIB to reflect SFN */
31208       /*First get the Most signficant 8 bits of SFN */
31209       sfnOctet = (U8)(crntTimInfo.sfn >> 2);
31210       /*Get the first two octets of MIB, and then update them
31211         using the SFN octet value obtained above.*/
31212       if(ROK != SExamMsg((Data *)(&mibOct1),
31213                cell->siCb.crntSiInfo.mib, 0))
31214          RETVOID;
31215
31216       if(ROK != SExamMsg((Data *)(&mibOct2),
31217                cell->siCb.crntSiInfo.mib, 1))
31218          RETVOID;
31219
31220       /* ccpu00114572- Fix for improper way of MIB Octet setting for SFN */
31221       mibOct1 = (mibOct1 & 0xFC) | (sfnOctet >> 6);
31222       mibOct2 = (mibOct2 & 0x03) | (sfnOctet << 2);
31223       /* ccpu00114572- Fix ends*/
31224
31225       /*Now, replace the two octets in MIB */
31226       if(ROK != SRepMsg((Data)(mibOct1),
31227                cell->siCb.crntSiInfo.mib, 0))
31228          RETVOID;
31229
31230       if(ROK != SRepMsg((Data)(mibOct2),
31231                cell->siCb.crntSiInfo.mib, 1))
31232          RETVOID;
31233
31234       /*Copy the MIB msg buff into interface buffer */
31235       SCpyMsgMsg(cell->siCb.crntSiInfo.mib,
31236             rgSchCb[cell->instIdx].rgSchInit.region,
31237             rgSchCb[cell->instIdx].rgSchInit.pool,
31238             &subfrmAlloc->cmnLcInfo.bchInfo.pdu);
31239       /* Added Dl TB count for MIB message transmission
31240        * This counter is incremented 4 times to consider 
31241        * the retransmission at the PHY level on PBCH channel*/
31242 #ifdef LTE_L2_MEAS
31243       cell->dlUlTbCnt.tbTransDlTotalCnt += RG_SCH_MIB_CNT;
31244 #endif      
31245    }
31246 #ifdef EMTC_ENABLE
31247    }
31248 #endif
31249
31250    allocInfo->bcchAlloc.schdFirst = FALSE;
31251    /*Check if scheduling of SIB1 is required.
31252      Check of (crntTimInfo.sfn % RGSCH_SIB1_PERIODICITY == 0)
31253      is not required here since the below check takes care
31254      of SFNs applicable for this one too.*/
31255    if((crntTimInfo.sfn % RGSCH_SIB1_RPT_PERIODICITY == 0)
31256          && (RGSCH_SIB1_TX_SF_NUM == crntTimInfo.slot))
31257    {
31258       /*If SIB1 has not been yet setup by Application, return*/
31259       if(NULLP == (cell->siCb.crntSiInfo.sib1Info.sib1))
31260       {
31261          RETVOID;
31262       }
31263
31264       allocInfo->bcchAlloc.schdFirst = TRUE;
31265       mcs =  cell->siCb.crntSiInfo.sib1Info.mcs;
31266       nPrb =  cell->siCb.crntSiInfo.sib1Info.nPrb;
31267       msgLen =  cell->siCb.crntSiInfo.sib1Info.msgLen;
31268    }
31269    else
31270    {
31271       /*Check if scheduling of SI can be performed.*/
31272       Bool    invalid = FALSE;
31273
31274       if(cell->siCb.siCtx.siId == 0)
31275          RETVOID;
31276
31277       /*Check if the Si-Window for the current Si-Context is completed*/
31278       invalid = rgSCHCmnChkPastWin(crntTimInfo, cell->siCb.siCtx.maxTimeToTx);
31279       if(invalid)
31280       {
31281          /* LTE_ADV_FLAG_REMOVED_START */
31282          if(cell->siCb.siCtx.retxCntRem)
31283          { 
31284             RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,(ErrVal)cell->siCb.siCtx.siId,
31285                                 "rgSCHDlSiSched(): SI not scheduled and window expired");
31286          }
31287          /* LTE_ADV_FLAG_REMOVED_END */
31288          if(cell->siCb.siCtx.warningSiFlag == TRUE)
31289          {
31290             rgSCHUtlFreeWarningSiPdu(cell);
31291             cell->siCb.siCtx.warningSiFlag  = FALSE;
31292          }
31293          RETVOID;
31294       }
31295
31296       /*Check the timinginfo of the current SI-Context to see if its
31297         transmission can be scheduled. */
31298       if(FALSE == (rgSCHCmnChkInWin(crntTimInfo,
31299                   cell->siCb.siCtx.timeToTx,
31300                   cell->siCb.siCtx.maxTimeToTx)))
31301       {
31302          RETVOID;
31303
31304       }
31305       /*Check if retransmission count has become 0*/
31306       if(0 == cell->siCb.siCtx.retxCntRem)
31307       {
31308          RETVOID;
31309       }
31310
31311       /* LTE_ADV_FLAG_REMOVED_START */
31312       /* Check if ABS is enabled/configured  */
31313       if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31314       {
31315          /* The pattern type is RGR_ABS_MUTE, then eNB need to blank the subframe */
31316          if(cell->lteAdvCb.absCfg.absPatternType & RGR_ABS_MUTE)
31317          {
31318             /* Determine next scheduling subframe is ABS or not */
31319             if(RG_SCH_ABS_ENABLED_ABS_SF == (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern
31320                   [((crntTimInfo.sfn*RGSCH_NUM_SUB_FRAMES) + crntTimInfo.slot) % RGR_ABS_PATTERN_LEN]))
31321             {
31322                /* Skip the SI scheduling to next tti */
31323                RETVOID;
31324             }
31325          }
31326       }
31327       /* LTE_ADV_FLAG_REMOVED_END */
31328
31329       /*Schedule the transmission of the current SI-Context */
31330       /*Find out the messg length for the SI message */
31331       /* warningSiFlag is to differentiate between Warning SI
31332        * and Other SI */
31333         if((rgSCHUtlGetMcsAndNPrb(cell, &nPrb, &mcs, &msgLen)) != ROK)
31334         {
31335            RETVOID; 
31336         }
31337
31338       cell->siCb.siCtx.i = RGSCH_CALC_SF_DIFF(crntTimInfo,
31339             cell->siCb.siCtx.timeToTx);
31340    } 
31341
31342
31343    /*Get the number of rb required */
31344    /*rgSCHCmnClcRbAllocForFxdTb(cell, msgLen, cellDl->ccchCqi, &rb);*/
31345    if(cellDl->bitsPerRb==0)
31346    {
31347       while ((rgTbSzTbl[0][0][rb]) < (U32) (msgLen*8))
31348       {
31349          rb++;
31350       }
31351       rb = rb+1;
31352    }
31353    else
31354    {
31355       rb = RGSCH_CEIL((msgLen*8), cellDl->bitsPerRb);
31356    }
31357    /* DwPTS Scheduling Changes Start */   
31358 #ifdef LTE_TDD
31359    if (sf->sfType == RG_SCH_SPL_SF_DATA) 
31360    {
31361       RGSCH_GET_SPS_SF_CFI(cell->bwCfg.dlTotalBw, cfi);
31362
31363       /* Calculate the less RE's because of DwPTS */
31364        lostRe = rb * (cellDl->noResPerRb[cfi] - cellDl->numReDwPts[cfi]);
31365
31366        /* Increase number of RBs in Spl SF to compensate for lost REs */
31367        rb += RGSCH_CEIL(lostRe, cellDl->numReDwPts[cfi]); 
31368    }
31369 #endif
31370    /* DwPTS Scheduling Changes End */   
31371    /*ccpu00115595- end*/
31372    /* Additional check to see if required RBs
31373     * exceeds the available */
31374    if (rb > sf->bw - sf->bwAssigned)
31375    {
31376       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,  "rgSCHDlSiSched(): "
31377          "BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
31378       RETVOID;
31379    }
31380
31381    /* Update the subframe Allocated BW field */
31382    sf->bwAssigned = sf->bwAssigned + rb;
31383
31384    /*Fill the parameters in allocInfo */
31385    allocInfo->bcchAlloc.rnti = RGSCH_SI_RNTI;
31386    allocInfo->bcchAlloc.dlSf = sf;
31387    allocInfo->bcchAlloc.rbsReq = rb;
31388    /*ccpu00116710- MCS is not getting assigned */
31389    allocInfo->bcchAlloc.tbInfo[0].imcs = mcs;
31390
31391    /* ccpu00117510 - ADD - Assignment of nPrb and other information */
31392    allocInfo->bcchAlloc.nPrb = nPrb;
31393    allocInfo->bcchAlloc.tbInfo[0].bytesReq = msgLen;
31394    allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
31395    RETVOID;
31396 }
31397 #endif /*RGR_SI_SCH*/
31398
31399 \f
31400 /* ccpu00117452 - MOD - Changed macro name from
31401    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
31402 #ifdef RGR_CQI_REPT
31403 /**
31404  * @brief This function Updates the DL CQI for the UE.
31405  *
31406  * @details
31407  *
31408  *     Function: rgSCHCmnUeDlPwrCtColltCqiRept
31409  *     Purpose:  Manages PUSH N CQI reporting
31410  *         Step 1: Store the CQI in collation array
31411  *         Step 2: Increament the tracking count
31412  *         Step 3: Check is it time to to send the report
31413  *         Step 4: if yes, Send StaInd to RRM
31414  *         Step 4.1: Fill StaInd for sending collated N CQI rpeorts
31415  *         Step 4.2: Call utility function (rgSCHUtlRgrStaInd) to send rpts to RRM
31416  *         Step 4.2.1: If sending was not sucessful, return RFAILED
31417  *         Step 4.2.2: If sending was sucessful, return ROK
31418  *         Step 5: If no, return
31419  *     Invoked by: rgSCHCmnDlCqiInd
31420  *
31421  *  @param[in]  RgSchCellCb        *cell
31422  *  @param[in]  RgSchUeCb          *ue
31423  *  @param[in]  RgrUeCqiRept        *ueCqiRpt
31424  *  @return  Void
31425  *
31426  **/
31427 #ifdef ANSI
31428 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept
31429 (
31430 RgSchCellCb        *cell,
31431 RgSchUeCb          *ue,
31432 RgrUeCqiRept        *ueCqiRpt
31433 )
31434 #else
31435 PRIVATE S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
31436 RgSchCellCb        *cell;
31437 RgSchUeCb          *ue;
31438 RgrUeCqiRept        *ueCqiRpt;
31439 #endif
31440 {
31441    U8    *cqiCount = NULLP;
31442    S16   retVal;
31443    RgrStaIndInfo *staInfo = NULLP;
31444
31445    TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
31446
31447    /* Step 1: Store the CQI in collation array */
31448    /* Step 2: Increament the tracking count */
31449    cqiCount = &(ue->schCqiInfo.cqiCount);
31450    ue->schCqiInfo.cqiRept[(*cqiCount)++] =
31451                   *ueCqiRpt;
31452
31453
31454    /* Step 3: Check is it time to to send the report */
31455    if(RG_SCH_CQIR_IS_TIMTOSEND_CQIREPT(ue))
31456    {
31457    /* Step 4: if yes, Send StaInd to RRM */
31458       retVal = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&staInfo,
31459                sizeof(RgrStaIndInfo));
31460       if (retVal != ROK)
31461       {
31462          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
31463             "allocate memory for sending StaInd CRNTI:%d",ue->ueId);
31464          RETVALUE(retVal);
31465       }
31466
31467    /* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
31468 #ifdef CA_DBG
31469       {
31470          extern U32 gCqiReptToAppCount;
31471          gCqiReptToAppCount++;
31472       
31473       }
31474
31475 #endif
31476       retVal = rgSCHUtlFillSndStaInd(cell, ue, staInfo,
31477             ue->cqiReptCfgInfo.numColltdCqiRept);
31478       RETVALUE(retVal);
31479
31480    }
31481
31482    RETVALUE(ROK);
31483 } /* End of rgSCHCmnUeDlPwrCtColltCqiRept */
31484
31485 #endif /* End of RGR_CQI_REPT */
31486
31487 /**
31488  * @brief This function checks for the retransmisson
31489  *        for a DTX scenario.
31490  * @details
31491  *
31492  *     Function:
31493  *     Purpose:
31494  *     Invoked by:
31495  *
31496  *  @param[in]  RgSchCellCb        *cell
31497  *  @param[in]  RgSchUeCb          *ue
31498  *  @param[in]
31499  *  @return  Void
31500  *
31501  **/
31502 #ifdef ANSI
31503 PUBLIC Void rgSCHCmnChkRetxAllowDtx
31504 (
31505 RgSchCellCb        *cell,
31506 RgSchUeCb          *ueCb,
31507 RgSchDlHqProcCb    *proc,
31508 Bool               *reTxAllwd
31509 )
31510 #else
31511 PUBLIC Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
31512 RgSchCellCb        *cell;
31513 RgSchUeCb          *ueCb;
31514 RgSchDlHqProcCb    *proc;
31515 Bool               *reTxAllwd;
31516 #endif
31517 {
31518    TRC3(rgSCHCmnChkRetxAllowDtx)
31519
31520
31521    *reTxAllwd = TRUE;
31522    /* Fix */
31523    if ((proc->tbInfo[0].isAckNackDtx == TFU_HQFDB_DTX))
31524    {
31525        *reTxAllwd = FALSE;
31526    }
31527
31528    RETVOID;
31529 }
31530
31531 /**
31532  * @brief API for calculating the SI Set Id 
31533  *
31534  * @details
31535  *
31536  *     Function: rgSCHCmnGetSiSetId
31537  *
31538  *     This API is used for calculating the SI Set Id, as shown below
31539  *     
31540  *          siSetId = 0        siSetId = 1
31541  *     |******************|******************|---------------->
31542  *   (0,0)              (8,0)              (16,0)          (SFN, SF)
31543  *    
31544  *
31545  *  @param[in]  U16     sfn                   
31546  *  @param[in]  U8      sf
31547  *  @return     U16     siSetId
31548  **/
31549 #ifdef ANSI
31550 PUBLIC U16 rgSCHCmnGetSiSetId
31551 (
31552 U16    sfn,
31553 U8     sf,
31554 U16    minPeriodicity
31555 )
31556 #else
31557 PUBLIC U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
31558 U16    sfn;
31559 U8     sf
31560 U16    minPeriodicity;
31561 #endif
31562 {
31563    /* 80 is the minimum SI periodicity in sf. Also
31564     * all other SI periodicities are multiples of 80 */
31565     RETVALUE (((sfn * RGSCH_NUM_SUB_FRAMES_5G) + sf) / (minPeriodicity * 10));
31566 }
31567 #ifdef LTE_TDD
31568 /**
31569  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31570  *
31571  * @details
31572  *
31573  *     Function: rgSCHCmnCalcDwPtsTbSz
31574  *
31575  *  @param[in]     RgSchCellCb    *cell                   
31576  *  @param[in]     U32             bo
31577  *  @param[in/out] U8             *rb
31578  *  @param[in/out] U8             *iTbs
31579  *  @param[in]     U8              lyr
31580  *  @param[in]     U8              cfi
31581  *  @return        U32             tbSz
31582  **/
31583 #ifdef ANSI
31584 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz
31585 (
31586 RgSchCellCb    *cell,
31587 U32             bo,
31588 U8             *rb,
31589 U8             *iTbs,
31590 U8              lyr,
31591 U8              cfi
31592 )
31593 #else
31594 PRIVATE U32 rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
31595 RgSchCellCb    *cell;
31596 U32             bo;
31597 U8             *rb;
31598 U8             *iTbs;
31599 U8              lyr;
31600 U8              cfi;
31601 #endif
31602 {
31603     U32             tbSz;
31604     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31605     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31606     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31607
31608     TRC2(rgSCHCmnCalcDwPtsTbSz);
31609
31610     /* DwPts Rb cannot exceed the cell Bw */
31611     numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
31612     
31613     /* Adjust the iTbs for optimum usage of the DwPts region. 
31614      * Using the same iTbs adjustment will not work for all 
31615      * special subframe configurations and iTbs levels. Hence use the 
31616      * static iTbs Delta table for adjusting the iTbs  */
31617     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs);
31618     
31619     if (bo)
31620     {
31621        while(rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1] < bo*8 &&
31622              numDwPtsRb < cellDl->maxDlBwPerUe) 
31623        {
31624           (numDwPtsRb)++;
31625        }
31626
31627        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31628     }
31629     else
31630     {
31631        tbSz = rgTbSzTbl[lyr-1][*iTbs][RGSCH_MAX(numDwPtsRb*3/4,1)-1];
31632     }
31633     *rb = numDwPtsRb;
31634
31635     RETVALUE(tbSz/8);
31636 }
31637
31638 /**
31639  * @brief API for calculating the DwPts Rb, Itbs and  tbSz 
31640  *
31641  * @details
31642  *
31643  *     Function: rgSCHCmnCalcDwPtsTbSz2Cw
31644  *
31645  *  @param[in]      RgSchCellCb    *cell                   
31646  *  @param[in]      U32             bo
31647  *  @param[in/out]  U8             *rb
31648  *  @param[in]      U8              maxRb
31649  *  @param[in/out]  U8             *iTbs1
31650  *  @param[in/out]  U8             *iTbs2
31651  *  @param[in]      U8              lyr1
31652  *  @param[in]      U8              lyr2
31653  *  @return[in/out] U32            *tb1Sz
31654  *  @return[in/out] U32            *tb2Sz
31655  *  @param[in]      U8              cfi 
31656  **/
31657 #ifdef ANSI
31658 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw
31659 (
31660 RgSchCellCb    *cell,
31661 U32             bo,
31662 U8             *rb,
31663 U8              maxRb,
31664 U8             *iTbs1,
31665 U8             *iTbs2,
31666 U8              lyr1,
31667 U8              lyr2,
31668 U32            *tb1Sz, 
31669 U32            *tb2Sz,
31670 U8              cfi
31671 )
31672 #else
31673 PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2, 
31674       lyr1, lyr2, tb1Sz, tb2Sz, cfi)
31675 RgSchCellCb    *cell;
31676 U32             bo;
31677 U8             *rb;
31678 U8              maxRb;
31679 U8             *iTbs1;
31680 U8             *iTbs2;
31681 U8              lyr1;
31682 U8              lyr2;
31683 U32            *tb1Sz; 
31684 U32            *tb2Sz;
31685 U8              cfi;
31686 #endif
31687 {
31688     RgSchCmnDlCell *cellDl     = RG_SCH_CMN_GET_DL_CELL(cell);
31689     U32             numRE      = *rb * cellDl->noResPerRb[cfi];
31690     U32             numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);   
31691
31692     TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
31693
31694     /* DwPts Rb cannot exceed the cell Bw */
31695     numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
31696     
31697     /* Adjust the iTbs for optimum usage of the DwPts region. 
31698      * Using the same iTbs adjustment will not work for all 
31699      * special subframe configurations and iTbs levels. Hence use the 
31700      * static iTbs Delta table for adjusting the iTbs  */
31701     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs1);
31702     RG_SCH_CMN_ADJ_DWPTS_ITBS(cellDl, *iTbs2);
31703     
31704     while((rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1] +
31705            rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1])< bo*8 &&
31706           numDwPtsRb < maxRb) 
31707     {
31708        (numDwPtsRb)++;
31709     }
31710
31711     *tb1Sz = rgTbSzTbl[lyr1-1][*iTbs1][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31712     *tb2Sz = rgTbSzTbl[lyr2-1][*iTbs2][RGSCH_MAX(numDwPtsRb*3/4,1)-1]/8;
31713
31714     *rb = numDwPtsRb;
31715
31716     RETVOID;    
31717 }
31718
31719 #endif
31720
31721 /**
31722  * @brief Updates the GBR LCGs when datInd is received from MAC
31723  * 
31724  * @details
31725  *
31726  *     Function: rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31727  *     Purpose:  This function updates the GBR LCGs 
31728  *               when datInd is received from MAC.
31729  *
31730  *     Invoked by: TOM
31731  *
31732  *  @param[in]  RgSchCellCb      *cell
31733  *  @param[in]  RgSchUeCb        *ue
31734  *  @param[in]  RgInfUeDatInd    *datInd
31735  *  @return Void
31736  **/
31737 #ifdef ANSI
31738 PUBLIC Void rgSCHCmnUpdUeDataIndLcg 
31739 (
31740 RgSchCellCb    *cell,
31741 RgSchUeCb      *ue,
31742 RgInfUeDatInd  *datInd
31743 )
31744 #else
31745 PUBLIC Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
31746 RgSchCellCb    *cell;
31747 RgSchUeCb      *ue;
31748 RgInfUeDatInd  *datInd;
31749 #endif
31750 {
31751    U32 idx = 0;
31752    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
31753 #ifdef DEBUGP
31754    Inst                inst = cell->instIdx;
31755 #endif
31756
31757    TRC2(rgSCHCmnUpdUeDataIndLcg);
31758
31759    for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
31760    {
31761       if (datInd->lcgInfo[idx].bytesRcvd != 0)
31762       {
31763          U8  lcgId     = datInd->lcgInfo[idx].lcgId;
31764          U32 bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
31765
31766          if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
31767          {
31768             RgSchCmnLcg *cmnLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgId].sch));
31769             if (RGSCH_IS_GBR_BEARER(cmnLcg->cfgdGbr))
31770             {
31771                if(bytesRcvd > cmnLcg->effGbr)
31772                {
31773                   bytesRcvd -= cmnLcg->effGbr;
31774                   cmnLcg->effDeltaMbr = (cmnLcg->effDeltaMbr > bytesRcvd) ? \
31775                                         (cmnLcg->effDeltaMbr - bytesRcvd) : (0);
31776                   cmnLcg->effGbr = 0;
31777                }
31778                else
31779                {
31780                   cmnLcg->effGbr -= bytesRcvd;
31781                }
31782                /* To keep BS updated with the amount of data received for the GBR */
31783                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31784                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31785                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, cmnLcg->effGbr+cmnLcg->effDeltaMbr);
31786             }
31787             else if(lcgId != 0)
31788             {
31789                ue->ul.effAmbr = (ue->ul.effAmbr > datInd->lcgInfo[idx].bytesRcvd) ? \
31790                                (ue->ul.effAmbr - datInd->lcgInfo[idx].bytesRcvd) : (0);
31791                cmnLcg->reportedBs = (cmnLcg->reportedBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31792                                     (cmnLcg->reportedBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31793                cmnLcg->bs = RGSCH_MIN(cmnLcg->reportedBs, ue->ul.effAmbr);
31794                ue->ul.nonGbrLcgBs = (ue->ul.nonGbrLcgBs > datInd->lcgInfo[idx].bytesRcvd) ? \
31795                                    (ue->ul.nonGbrLcgBs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31796             }
31797             ue->ul.nonLcg0Bs = (ue->ul.nonLcg0Bs > datInd->lcgInfo[idx].bytesRcvd) ? \
31798                               (ue->ul.nonLcg0Bs - datInd->lcgInfo[idx].bytesRcvd) : (0);
31799          }
31800       }
31801       else
31802       {
31803          break;
31804       }
31805    }
31806 #ifdef EMTC_ENABLE
31807    if(TRUE == ue->isEmtcUe)
31808    {
31809       if (cellSch->apisEmtcUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31810       {
31811          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31812       }
31813
31814    }
31815    else
31816 #endif
31817    {
31818       if (cellSch->apisUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
31819       {
31820          RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
31821       }
31822    }
31823 }
31824
31825
31826 /** @brief This function initializes DL allocation lists and prepares
31827  *         for scheduling  
31828  *
31829  * @details
31830  *
31831  *     Function: rgSCHCmnInitRbAlloc
31832  *
31833  * @param  [in] RgSchCellCb    *cell
31834  *
31835  * Returns: Void
31836  *
31837  */
31838 #ifdef ANSI
31839 PRIVATE Void  rgSCHCmnInitRbAlloc 
31840 (
31841 RgSchCellCb        *cell
31842 )
31843 #else
31844 PRIVATE Void  rgSCHCmnInitRbAlloc (cell)
31845 RgSchCellCb        *cell;
31846 #endif
31847 {
31848    RgSchCmnCell           *cellSch = RG_SCH_CMN_GET_CELL(cell);
31849    CmLteTimingInfo        frm;
31850    RgSchDlSf              *dlSf;
31851         U8                     idx;
31852    
31853    TRC2(rgSCHCmnInitRbAlloc);
31854
31855 /* Initializing RgSchCmnUlRbAllocInfo structure.*/
31856    rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
31857
31858    frm = cellSch->dl.time;
31859
31860    dlSf = rgSCHUtlSubFrmGet(cell, frm);
31861 #ifdef RG_5GTF
31862    dlSf->numGrpPerTti = cell->cell5gtfCb.ueGrpPerTti;
31863    dlSf->numUePerGrp = cell->cell5gtfCb.uePerGrpPerTti;
31864         for(idx = 0; idx < MAX_5GTF_BEAMS; idx++)
31865    {
31866       dlSf->sfBeamInfo[idx].totVrbgAllocated = 0;
31867       dlSf->sfBeamInfo[idx].totVrbgRequired = 0;
31868       dlSf->sfBeamInfo[idx].vrbgStart = 0;
31869    }
31870 #endif
31871    dlSf->remUeCnt = cellSch->dl.maxUePerDlSf;
31872    /* Updating the Subframe information in RBAllocInfo */
31873    cellSch->allocInfo.dedAlloc.dedDlSf   = dlSf;
31874    cellSch->allocInfo.msg4Alloc.msg4DlSf = dlSf;
31875
31876    /* LTE_ADV_FLAG_REMOVED_START */
31877    /* Determine next scheduling subframe is ABS or not */
31878    if(RGR_ENABLE == cell->lteAdvCb.absCfg.status)
31879    {
31880       cell->lteAdvCb.absPatternDlIdx = 
31881          ((frm.sfn*RGSCH_NUM_SUB_FRAMES_5G) + frm.slot) % RGR_ABS_PATTERN_LEN;
31882       cell->lteAdvCb.absDlSfInfo = (RgSchAbsSfEnum)(cell->lteAdvCb.absCfg.absPattern[
31883             cell->lteAdvCb.absPatternDlIdx]);
31884
31885    }
31886    else
31887    {
31888       cell->lteAdvCb.absDlSfInfo = RG_SCH_ABS_DISABLED;
31889    }
31890    /* LTE_ADV_FLAG_REMOVED_END */
31891
31892 #ifdef RGR_V1
31893    cellSch->allocInfo.ccchSduAlloc.ccchSduDlSf = dlSf;
31894 #endif
31895 #ifdef LTEMAC_SPS
31896    /* Update subframe-wide allocation information with SPS allocation */
31897    rgSCHCmnSpsDlUpdDlSfAllocWithSps(cell, frm, dlSf);
31898 #endif
31899    RETVOID;
31900 }
31901
31902
31903
31904 #ifdef DL_LA
31905 /**
31906  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31907  * actual iTbs
31908  * 
31909  * @details
31910  *
31911  *     Function: rgSCHCmnSendTxModeInd(cell, ueUl, newTxMode)
31912  *     Purpose:  This function sends the TX mode Change 
31913  *               indication to RRM
31914  *     change
31915  *
31916  *     Invoked by: CMN
31917  *
31918  *  @param[in]  RgSchCellCb      *cell
31919  *  @param[in]  RgSchUeCb        *ue
31920  *  @param[in]  U8               newTxMode
31921  *  @return Void
31922  **/
31923 #ifdef ANSI
31924 PRIVATE Void rgSCHCmnSendTxModeInd 
31925 (
31926 RgSchCellCb    *cell,
31927 RgSchUeCb      *ue,
31928 U8             newTxMode
31929 )
31930 #else
31931 PRIVATE Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
31932 RgSchCellCb    *cell;
31933 RgSchUeCb      *ue;
31934 U8             newTxMode;
31935 #endif
31936 { 
31937    RgmTransModeInd   *txModeChgInd;
31938    RgSchCmnDlUe      *ueDl =  RG_SCH_CMN_GET_DL_UE(ue,cell);
31939
31940    TRC2(rgSCHCmnSendTxModeInd);
31941
31942    if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
31943    {
31944       /* Mem Alloc */
31945       if(SGetSBuf(cell->rgmSap->sapCfg.sapPst.region,
31946                cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
31947                sizeof(RgmTransModeInd)) != ROK)
31948       {
31949          RETVOID;
31950       }
31951       RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
31952       RgUiRgmChangeTransModeInd(&(cell->rgmSap->sapCfg.sapPst),
31953             cell->rgmSap->sapCfg.suId, txModeChgInd);
31954    }
31955
31956    ue->mimoInfo.txModUpChgFactor = 0;
31957    ue->mimoInfo.txModDownChgFactor = 0;
31958    ueDl->laCb[0].deltaiTbs = 0;
31959
31960    RETVOID;
31961 }
31962
31963 /**
31964  * @brief Check & Updates the TM Mode chnage threashold based on cqiiTbs and
31965  * actual iTbs
31966  * 
31967  * @details
31968  *
31969  *     Function: rgSchCheckAndTriggerModeChange(cell, ueUl, iTbsNew)
31970  *     Purpose:  This function update and check for threashold for TM mode
31971  *     change
31972  *
31973  *     Invoked by: CMN
31974  *
31975  *  @param[in]  RgSchCellCb      *cell
31976  *  @param[in]  RgSchUeCb        *ue
31977  *  @param[in]  U8               iTbs
31978  *  @return Void
31979  **/
31980 #ifdef ANSI
31981 PUBLIC Void rgSchCheckAndTriggerModeChange
31982 (
31983 RgSchCellCb    *cell,
31984 RgSchUeCb      *ue,
31985 U8             reportediTbs,
31986 U8             previTbs,
31987 U8             maxiTbs
31988 )
31989 #else
31990 PUBLIC Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
31991 RgSchCellCb    *cell;
31992 RgSchUeCb      *ue;
31993 U8             reportediTbs;
31994 U8             previTbs;
31995 U8             maxiTbs;
31996 #endif
31997 {
31998    RgrTxMode          txMode;       /*!< UE's Transmission Mode */
31999    RgrTxMode          modTxMode;       /*!< UE's Transmission Mode */
32000
32001    TRC2(rgSchCheckAndTriggerModeChange);
32002
32003    txMode = ue->mimoInfo.txMode;
32004
32005    /* Check for Step down */
32006    /* Step down only when TM4 is configured. */
32007    if(RGR_UE_TM_4 == txMode)
32008    {
32009       if((previTbs <= reportediTbs) && ((reportediTbs - previTbs) >= RG_SCH_MODE_CHNG_STEPDOWN_CHECK_FACTOR))
32010       {
32011          ue->mimoInfo.txModDownChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32012       }
32013       else
32014       {
32015          ue->mimoInfo.txModDownChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32016       }
32017
32018       ue->mimoInfo.txModDownChgFactor =  
32019          RGSCH_MAX(ue->mimoInfo.txModDownChgFactor, -(RG_SCH_MODE_CHNG_STEPDOWN_THRSHD));
32020
32021       if(ue->mimoInfo.txModDownChgFactor >= RG_SCH_MODE_CHNG_STEPDOWN_THRSHD)
32022       {
32023          /* Trigger Mode step down */
32024          modTxMode = RGR_UE_TM_3;
32025          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32026       }
32027    }
32028
32029    /* Check for Setup up */
32030    /* Step Up only when TM3 is configured, Max possible Mode is TM4*/
32031    if(RGR_UE_TM_3 == txMode)
32032    {
32033       if((previTbs > reportediTbs) || (maxiTbs == previTbs))
32034       {
32035          ue->mimoInfo.txModUpChgFactor += RG_SCH_MODE_CHNG_STEPUP_FACTOR;
32036       }
32037       else
32038       {
32039          ue->mimoInfo.txModUpChgFactor -= RG_SCH_MODE_CHNG_STEPDOWN_FACTOR;
32040       }
32041
32042       ue->mimoInfo.txModUpChgFactor = 
32043          RGSCH_MAX(ue->mimoInfo.txModUpChgFactor, -(RG_SCH_MODE_CHNG_STEPUP_THRSHD));
32044
32045       /* Check if TM step up need to be triggered */
32046       if(ue->mimoInfo.txModUpChgFactor >= RG_SCH_MODE_CHNG_STEPUP_THRSHD)
32047       {
32048          /* Trigger mode chnage */
32049          modTxMode =  RGR_UE_TM_4;
32050          rgSCHCmnSendTxModeInd(cell, ue, modTxMode);
32051       }
32052    }
32053
32054    RETVOID;
32055 }
32056 #endif
32057
32058 /**
32059 * @brief Updates the GBR LCGs when datInd is received from MAC
32060  * 
32061  * @details
32062  *
32063  *     Function: rgSCHCmnIsDlCsgPrio (cell)
32064  *     Purpose:  This function returns if csg UEs are
32065  *               having priority at current time
32066  *
32067  *     Invoked by: Scheduler
32068  *
32069  *  @param[in]  RgSchCellCb      *cell
32070  *  @param[in]  RgSchUeCb        *ue
32071  *  @param[in]  RgInfUeDatInd    *datInd
32072  *  @return Void
32073  **/
32074 #ifdef ANSI
32075 PUBLIC Bool rgSCHCmnIsDlCsgPrio
32076 (
32077 RgSchCellCb    *cell
32078 )
32079 #else
32080 PUBLIC Bool rgSCHCmnIsDlCsgPrio(cell)
32081 RgSchCellCb    *cell;
32082 #endif
32083 {
32084   
32085    RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
32086  
32087    TRC2(rgSCHCmnIsDlCsgPrio)
32088    /* Calculating the percentage resource allocated */
32089    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32090    {
32091       RETVALUE(FALSE);
32092    }
32093    else
32094    {
32095       if(((cmnDlCell->ncsgPrbCnt * 100) / cmnDlCell->totPrbCnt) < cell->minDlResNonCsg)
32096       {
32097          RETVALUE(FALSE);
32098       }
32099       else
32100       {
32101          RETVALUE(TRUE);
32102       }
32103    }
32104 }
32105
32106 /**
32107 * @brief Updates the GBR LCGs when datInd is received from MAC
32108  * 
32109  * @details
32110  *
32111  *     Function: rgSCHCmnIsUlCsgPrio (cell)
32112  *     Purpose:  This function returns if csg UEs are
32113  *               having priority at current time
32114  *
32115  *     Invoked by: Scheduler
32116  *
32117  *  @param[in]  RgSchCellCb      *cell
32118  *  @param[in]  RgSchUeCb        *ue
32119  *  @param[in]  RgInfUeDatInd    *datInd
32120  *  @return Void
32121  **/
32122 #ifdef ANSI
32123 PUBLIC Bool rgSCHCmnIsUlCsgPrio
32124 (
32125 RgSchCellCb    *cell
32126 )
32127 #else
32128 PUBLIC Bool rgSCHCmnIsUlCsgPrio(cell)
32129 RgSchCellCb    *cell;
32130 #endif
32131 {
32132    RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
32133  
32134    TRC2(rgSCHCmnIsUlCsgPrio)
32135
32136    /* Calculating the percentage resource allocated */
32137    if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
32138    {
32139       RETVALUE(FALSE);
32140    }
32141    else
32142    {
32143       if (((cmnUlCell->ncsgPrbCnt * 100) /cmnUlCell->totPrbCnt) < cell->minUlResNonCsg)
32144       {
32145          RETVALUE(FALSE);
32146       }
32147       else
32148       {
32149          RETVALUE(TRUE);
32150       }
32151    }
32152 }
32153
32154 /** @brief DL scheduler for SPS, and all other downlink data
32155  *
32156  * @details
32157  *
32158  *      Function: rgSchCmnPreDlSch
32159  *
32160  *  @param  [in] Inst               schInst;
32161  *   Returns: Void
32162  *
32163  */
32164 #ifdef ANSI
32165    PUBLIC Void rgSchCmnPreDlSch
32166 (
32167  RgSchCellCb        **cell,
32168  U8                 nCell,
32169  RgSchCellCb        **cellLst
32170  )
32171 #else
32172 PUBLIC Void rgSchCmnPreDlSch(cell, nCell, cellLst)
32173    RgSchCellCb        **cell;
32174    U8                 nCell;
32175    RgSchCellCb        **cellLst;
32176 #endif
32177 {
32178    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
32179    RgSchDlSf     *sf;
32180    U8            idx;
32181
32182    TRC2(rgSchCmnPreDlSch);
32183
32184    if(nCell > CM_LTE_MAX_CELLS)
32185    {
32186       RETVOID;
32187    }
32188
32189    if (cell[0]->isDlDataAllwd && (cell[0]->stopDlSch == FALSE))
32190    {
32191       /* Specific DL scheduler to perform UE scheduling */
32192       cellSch->apisDl->rgSCHDlPreSched(cell[0]);
32193
32194       /* Rearranging the cell entries based on their remueCnt in SF.
32195        * cells will be processed in the order of number of ue scheduled
32196        * in that cell */
32197       for (idx = 0; idx < nCell; idx++)
32198       {
32199          U8    j;
32200          cellSch = RG_SCH_CMN_GET_CELL(cell[idx]);
32201          sf = cellSch->allocInfo.dedAlloc.dedDlSf;
32202
32203          if(idx == 0)
32204          {
32205             cellLst[idx] = cell[idx];
32206             continue;
32207          }
32208
32209          for(j = 0; j < idx; j++)
32210          {
32211             RgSchCmnCell *cmnCell = RG_SCH_CMN_GET_CELL(cellLst[j]);
32212             RgSchDlSf    *subfrm = cmnCell->allocInfo.dedAlloc.dedDlSf;
32213
32214             if(sf->remUeCnt < subfrm->remUeCnt)
32215             {
32216                U8  k;
32217                for(k = idx; k > j; k--)
32218                {
32219                   cellLst[k] = cellLst[k-1];
32220                }
32221                break;
32222             }
32223          }
32224          cellLst[j] = cell[idx];
32225       }
32226    }
32227    else
32228    {
32229       for (idx = 0; idx < nCell; idx++)
32230       {
32231          cellLst[idx] = cell[idx];
32232       }
32233    }
32234    RETVOID;
32235 }
32236
32237 /** @brief DL scheduler for SPS, and all other downlink data
32238  *  @details
32239  *
32240  *       Function: rgSchCmnPstDlSch
32241  *
32242  *        @param  [in] Inst               schInst;
32243  *        Returns: Void
32244  *
32245  */
32246 #ifdef ANSI
32247 PUBLIC Void rgSchCmnPstDlSch
32248 (
32249  RgSchCellCb       *cell
32250 )
32251 #else
32252 PUBLIC Void rgSchCmnPstDlSch(cell)
32253    RgSchCellCb        *cell
32254 #endif
32255 {
32256    RgSchCmnCell  *cellSch = RG_SCH_CMN_GET_CELL(cell);
32257
32258    TRC2(rgSchCmnPstDlSch);
32259
32260    if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
32261    {
32262       cellSch->apisDl->rgSCHDlPstSched(cell->instIdx);
32263    }
32264 }
32265
32266 #ifdef ANSI
32267 PUBLIC U8 rgSCHCmnCalcPcqiBitSz
32268 (
32269  RgSchUeCb    *ueCb, 
32270  U8           numTxAnt
32271 )
32272 #else
32273 PUBLIC U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
32274    RgSchUeCb     *ueCb;
32275    U8            numTxAnt;
32276 #endif
32277 {
32278    U8 confRepMode;
32279    U8 pcqiSz;
32280    U8 ri;
32281    RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
32282
32283    TRC3(rgSCHCmnCalcPcqiBitSz);
32284
32285    confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
32286    if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) && 
32287          (ueCb->mimoInfo.txMode != RGR_UE_TM_4))
32288    {
32289       ri =1;
32290    }
32291    else
32292    {
32293       ri = cqiCb->perRiVal;
32294    }
32295    switch(confRepMode)
32296    {
32297       case RGR_PRD_CQI_MOD10:
32298          {
32299             pcqiSz = 4;
32300          }
32301          break;
32302
32303       case RGR_PRD_CQI_MOD11:
32304          {
32305             if(numTxAnt == 2)
32306             {
32307                if (ri ==1)
32308                {
32309                   pcqiSz = 6;
32310                }
32311                else
32312                {
32313                   pcqiSz = 8;
32314                }
32315             }
32316             else if(numTxAnt == 4)
32317             {
32318                if (ri ==1)
32319                {
32320                   pcqiSz = 8;
32321                }
32322                else
32323                {
32324                   pcqiSz = 11;
32325                }
32326             }
32327             else
32328             {
32329                /* This is number of antenna case 1.
32330                 * This is not applicable for Mode 1-1. 
32331                 * So setting it to invalid value */
32332                pcqiSz = 0;
32333             }
32334          }
32335          break;
32336
32337       case RGR_PRD_CQI_MOD20:
32338          {
32339             if(cqiCb->isWb)
32340             {
32341                pcqiSz = 4;
32342             }
32343             else
32344             {
32345                pcqiSz = 4 + cqiCb->label;
32346             }
32347          }
32348          break;
32349
32350       case RGR_PRD_CQI_MOD21:
32351          {
32352             if(cqiCb->isWb)
32353             {
32354                if(numTxAnt == 2)
32355                {
32356                   if (ri ==1)
32357                   {
32358                      pcqiSz = 6;
32359                   }
32360                   else
32361                   {
32362                      pcqiSz = 8;
32363                   }
32364                }
32365                else if(numTxAnt == 4)
32366                {
32367                   if (ri ==1)
32368                   {
32369                      pcqiSz = 8;
32370                   }
32371                   else
32372                   {
32373                      pcqiSz = 11;
32374                   }
32375                }
32376                else
32377                {
32378                   /* This might be number of antenna case 1.
32379                    * For mode 2-1 wideband case only antenna port 2 or 4 is supported.
32380                    * So setting invalid value.*/
32381                   pcqiSz = 0;
32382                }
32383             }
32384             else
32385             {
32386                if (ri ==1)
32387                {
32388                   pcqiSz = 4 + cqiCb->label;
32389                }
32390                else
32391                {
32392                   pcqiSz = 7 + cqiCb->label;
32393                }
32394             }
32395          }
32396          break;
32397       default:
32398           pcqiSz = 0;
32399           break;
32400    }
32401    
32402    RETVALUE(pcqiSz);
32403 }
32404
32405 /** @brief DL scheduler for SPS, and all other downlink data
32406  *
32407  * @details
32408  *
32409  *     Function: rgSCHCmnDlSch
32410  *
32411  * @param  [in] RgSchCellCb    *cell
32412  *
32413  * Returns: Void
32414  *
32415  */
32416 #ifdef ANSI
32417 PUBLIC Void rgSCHCmnDlSch
32418 (
32419  RgSchCellCb        *cell
32420  )
32421 #else
32422 PUBLIC Void rgSCHCmnDlSch (cell)
32423    RgSchCellCb        *cell;
32424 #endif
32425 {
32426    RgSchDlSf *dlSf;
32427    RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
32428 #ifdef RG_5GTF
32429    RgSchDynTddCb  *rgSchDynTddInfo = &(rgSchCb[cell->instIdx].rgSchDynTdd);
32430    U16 dlCntrlSfIdx;
32431 #endif
32432
32433    TRC2(rgSCHCmnDlSch);
32434
32435    dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
32436 #ifdef RG_5GTF
32437         if (rgSchDynTddInfo->isDynTddEnbld)
32438    {
32439       RG_SCH_DYN_TDD_GET_SFIDX(dlCntrlSfIdx, rgSchDynTddInfo->crntDTddSfIdx, 
32440                                             RG_SCH_CMN_DL_DELTA);
32441                 if(RG_SCH_DYNTDD_DLC_ULD == rgSchDynTddInfo->sfInfo[dlCntrlSfIdx].sfType)
32442                 {
32443                    if(1 == cell->cellId)
32444          {
32445                       ul5gtfsidDlAlreadyMarkUl++;
32446             /*
32447                       printf("ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n", 
32448                     ul5gtfsidDlAlreadyMarkUl, cellSch->dl.time.sfn, 
32449                     cellSch->dl.time.slot);
32450             */
32451          }
32452                    RETVOID;
32453                 }
32454    }
32455 #endif
32456
32457    /* Specific DL scheduler to perform UE scheduling */
32458    cellSch->apisDl->rgSCHDlNewSched(cell, &cellSch->allocInfo);      
32459    /* LTE_ADV_FLAG_REMOVED_END */
32460
32461    /* call common allocator for RB Allocation */
32462    rgSCHCmnDlRbAlloc(cell, &cellSch->allocInfo);
32463
32464    /* Finalize the Allocations for reqested Against alloced */
32465    rgSCHCmnDlAllocFnlz(cell);
32466
32467    /* Perform Pdcch allocations for PDCCH Order Q.
32468     * As of now, giving this the least preference.
32469     * This func call could be moved above other allocations
32470     * as per need */
32471    rgSCHCmnGenPdcchOrder(cell, dlSf);
32472
32473    /* Do group power control for PUCCH */
32474    rgSCHCmnGrpPwrCntrlPucch(cell, dlSf);
32475
32476    RETVOID;
32477 }
32478
32479 /**********************************************************************
32480
32481   End of file
32482 **********************************************************************/
O-RAN DU Layer 2