[Epic-ID: ODUHIGH-517][Task-ID: ODUHIGH-540][Sub-Task-ID: ODUHIGH-548]| MUlti UE...
[o-du/l2.git] / src / 5gnrsch / sch_common.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:     5G NR SCH layer
22
23 Type:     C source file
24
25 Desc:     C source code for Entry point fucntions
26
27 File:     sch_common.c
28
29  **********************************************************************/
30
31 /** @file sch_common.c
32   @brief This module performs common scheduling
33  */
34 #include "common_def.h"
35 #include "tfu.h"
36 #include "lrg.h"
37
38 #include "tfu.x"
39 #include "lrg.x"
40 #include "du_log.h"
41 #include "du_app_mac_inf.h"
42 #include "mac_sch_interface.h"
43 #include "sch.h"
44 #include "sch_tmr.h"
45 #include "sch_utils.h"
46
47 /**
48  * @brief common resource allocation for SSB
49  *
50  * @details
51  *
52  *     Function : schBroadcastSsbAlloc
53  *     
54  *     This function handles common scheduling for SSB
55  *     
56  *  @param[in]  SchCellCb *cell, cell cb
57  *  @param[in]  DlBrdcstAlloc *dlBrdcstAlloc, DL brdcst allocation
58  *  @return  void
59  **/
60 uint8_t schBroadcastSsbAlloc(SchCellCb *cell, SlotTimingInfo slotTime, DlBrdcstAlloc *dlBrdcstAlloc)
61 {
62    /* schedule SSB */
63    uint8_t ssbStartSymb, idx;
64    uint16_t ssbStartPrb;
65    SchDlSlotInfo *schDlSlotInfo;
66    SsbInfo ssbInfo;
67
68    if(cell == NULL)
69    {
70       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : Cell is NULL");
71       return RFAILED;
72    }
73
74    if(dlBrdcstAlloc == NULL)
75    {
76       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
77       return RFAILED;
78    }
79
80    schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
81    ssbStartPrb = cell->cellCfg.ssbSubcOffset; //+Kssb
82    ssbStartSymb = cell->ssbStartSymbArr[dlBrdcstAlloc->ssbIdxSupported-1]; /*since we are supporting only 1 ssb beam */
83
84    /* Assign interface structure */
85    for(idx=0; idx<dlBrdcstAlloc->ssbIdxSupported; idx++)
86    {
87       ssbInfo.ssbIdx              = idx;
88       ssbInfo.fdAlloc.startPrb    = ssbStartPrb;
89       ssbInfo.fdAlloc.numPrb      = SCH_SSB_NUM_PRB;
90       ssbInfo.tdAlloc.startSymb   = ssbStartSymb;
91       ssbInfo.tdAlloc.numSymb     = SCH_SSB_NUM_SYMB;
92       dlBrdcstAlloc->ssbInfo[idx] = ssbInfo;
93       schDlSlotInfo->ssbInfo[idx] = ssbInfo;
94    }
95
96    if((allocatePrbDl(cell, slotTime, ssbStartSymb, SCH_SSB_NUM_SYMB, &ssbInfo.fdAlloc.startPrb, ssbInfo.fdAlloc.numPrb)) != ROK)
97    {
98        DU_LOG("\nERROR  -->  SCH: PRB allocation failed for SSB in SFN:SLOT [%d : %d]", slotTime.sfn, slotTime.slot);
99        return RFAILED;
100    }
101
102
103    schDlSlotInfo->ssbPres = true;
104    schDlSlotInfo->ssbIdxSupported = dlBrdcstAlloc->ssbIdxSupported;
105    return ROK;
106 }
107
108 /**
109  * @brief common resource allocation for SIB1
110  *
111  * @details
112  *
113  *     Function : schBroadcastSib1Alloc
114  *     
115  *     This function handles common scheduling for SIB1
116  *     
117  *  @param[in]  SchCellCb *cell, cell cb
118  *  @param[in]  DlBrdcstAlloc *dlBrdcstAlloc, DL brdcst allocation
119  *  @return  void
120  **/
121 uint8_t schBroadcastSib1Alloc(SchCellCb *cell, SlotTimingInfo slotTime, DlBrdcstAlloc *dlBrdcstAlloc)
122 {
123    uint8_t dmrsStartSymbol, startSymbol, numSymbol ;
124    DmrsInfo dmrs;
125    PdschFreqAlloc freqAlloc;
126    PdschTimeAlloc timeAlloc;
127    SchDlSlotInfo *schDlSlotInfo = NULLP;
128
129    if(cell == NULL)
130    {
131       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : Cell is NULL");
132       return RFAILED;
133    }
134
135    if(dlBrdcstAlloc == NULL)
136    {
137       DU_LOG("\nERROR  -->  SCH: schBroadcastSsbAlloc() : dlBrdcstAlloc is NULL");
138       return RFAILED;
139    }
140    
141    dlBrdcstAlloc->crnti = SI_RNTI;
142    dmrs = cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.dmrs;
143    freqAlloc = cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschFreqAlloc;
144    timeAlloc = cell->sib1SchCfg.sib1PdcchCfg.dci[0].pdschCfg.pdschTimeAlloc;
145    schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
146
147    /* Find total symbols used including DMRS */
148    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
149     * in that case only PDSCH symbols are marked as occupied */
150    dmrsStartSymbol = findDmrsStartSymbol(dmrs.dlDmrsSymbPos);   
151    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
152    {
153       startSymbol = timeAlloc.startSymb;
154       numSymbol = timeAlloc.numSymb;
155    }
156    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
157    else
158    {
159       startSymbol = dmrsStartSymbol;
160       numSymbol = dmrs.nrOfDmrsSymbols + timeAlloc.numSymb;
161    }
162
163    /* Allocate PRB */
164    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol, &freqAlloc.startPrb, freqAlloc.numPrb)) != ROK)
165    {
166        DU_LOG("\nERROR  -->  SCH: PRB allocation failed for SIB1 in SFN:Slot [%d : %d]", slotTime.sfn, slotTime.slot);
167        return RFAILED;
168    }
169
170    memcpy(&dlBrdcstAlloc->sib1Alloc.bwp, &cell->sib1SchCfg.bwp, sizeof(BwpCfg)); 
171    SCH_ALLOC(dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg,sizeof(PdcchCfg));
172    if(dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg)
173    {
174       memcpy(dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg, &cell->sib1SchCfg.sib1PdcchCfg, sizeof(PdcchCfg)); 
175       schDlSlotInfo->sib1Pres = true;
176    }
177    else
178    {
179       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in %s", __func__);
180       return RFAILED;
181    }
182    return ROK;
183 }
184
185 /*******************************************************************
186  *
187  * @brief Handles sending UL scheduler info to MAC 
188  *
189  * @details
190  *
191  *    Function : sendUlSchInfoToMac
192  *
193  *    Functionality:
194  *     Sends UL Sch info to MAC from SCH
195  *
196  * @params[in] 
197  * @return ROK     - success
198  *         RFAILED - failure
199  *
200  * ****************************************************************/
201 int sendUlSchInfoToMac(UlSchedInfo *ulSchedInfo, Inst inst)
202 {
203    Pst pst;
204
205    memset(&pst, 0, sizeof(Pst));
206    FILL_PST_SCH_TO_MAC(pst, inst);
207    pst.event = EVENT_UL_SCH_INFO;
208
209    return(MacMessageRouter(&pst, (void *)ulSchedInfo));
210 }
211
212 /**
213  * @brief Function to fill Pucch Format 0
214  *
215  * @details
216  *
217  *     Function : fillPucchFormat0
218  *     
219  *     Function to fill Pucch format 0
220  *     
221  *  @param[in]  SchPucchInfo pointer, SchPucchResrcInfo pointer
222  *  @return  void
223  **/
224
225 void fillPucchFormat0(SchPucchInfo *ulSchedPucch, SchPucchResrcInfo *resrcInfo)
226 {
227    if(resrcInfo->SchPucchFormat.format0)
228    {
229       ulSchedPucch->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
230       ulSchedPucch->pucchFormat  = PUCCH_FORMAT_0;
231       ulSchedPucch->initialCyclicShift =  resrcInfo->SchPucchFormat.format0->initialCyclicShift;
232       ulSchedPucch->tdAlloc.numSymb = resrcInfo->SchPucchFormat.format0->numSymbols;
233       ulSchedPucch->tdAlloc.startSymb = resrcInfo->SchPucchFormat.format0->startSymbolIdx;
234    }
235 }
236
237 /**
238  * @brief Function to fill Pucch Format 1
239  *
240  * @details
241  *
242  *     Function : fillPucchFormat1
243  *     
244  *     Function to fill Pucch format 1
245  *     
246  *  @param[in]  SchPucchInfo pointer, SchPucchResrcInfo pointer
247  *  @return  void
248  **/
249
250 void fillPucchFormat1(SchPucchInfo *ulSchedPucch, SchPucchResrcInfo *resrcInfo)
251 {
252    if(resrcInfo->SchPucchFormat.format1)
253    {
254       ulSchedPucch->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
255       ulSchedPucch->pucchFormat  = PUCCH_FORMAT_1;
256       ulSchedPucch->initialCyclicShift =  resrcInfo->SchPucchFormat.format1->initialCyclicShift;
257       ulSchedPucch->tdAlloc.numSymb = resrcInfo->SchPucchFormat.format1->numSymbols;
258       ulSchedPucch->tdAlloc.startSymb = resrcInfo->SchPucchFormat.format1->startSymbolIdx;
259       ulSchedPucch->timeDomOCC =  resrcInfo->SchPucchFormat.format1->timeDomOCC;
260   }
261 }
262
263 /**
264  * @brief Function to fill Pucch format for UL Sched Info
265  *
266  * @details
267  *
268  *     Function : fillUlSchedPucchFormat
269  *     
270  *     Function to fill Pucch format for UL Sched Info
271  *     
272  *  @param[in]  pucchFormat , SchPucchInfo pointer,
273  *  @param[in]  SchPucchFormatCfg pointer, SchPucchResrcInfo pointer
274  *  @return  void
275  **/
276
277 uint8_t fillUlSchedPucchFormat(uint8_t pucchFormat, SchPucchInfo *ulSchedPucch,\
278    SchPucchResrcInfo *resrcInfo, SchPucchFormatCfg *formatCfg)
279 {
280    uint8_t ret = ROK;
281
282    switch(pucchFormat)
283    {
284       case PUCCH_FORMAT_0:
285          {
286             if(resrcInfo)
287                fillPucchFormat0(ulSchedPucch, resrcInfo);
288             return ret;
289          }
290       case PUCCH_FORMAT_1:
291          {
292             if(resrcInfo)
293             {
294                fillPucchFormat1(ulSchedPucch, resrcInfo);
295             }
296             if(formatCfg)
297             {
298                ulSchedPucch->addDmrs = formatCfg->addDmrs;
299                ulSchedPucch->pi2BPSK = formatCfg->pi2BPSK;
300             }
301             return ret;
302          }/* To Add support for more Pucch Format */
303
304       default:
305          DU_LOG("\nERROR  --> SCH : Invalid PUCCH format[%d] in fillUlSchedPucchFormatCfg()", pucchFormat);
306          ret = RFAILED;
307          return ret;
308    }
309    return ret;
310 }
311
312 /**
313  * @brief Function to fill Pucch Dedicated Cfg for UL Sched Info
314  *
315  * @details
316  *
317  *     Function : fillUlSchedPucchDedicatedCfg
318  *     
319  *     Function to fill Pucch Dedicated Cfg for UL Sched Info
320  *     
321  *  @param[in]  pucchFormat to be filled
322  *  @param[in]  SchPucchFormatCfg pointer, SchPucchCfg pointer
323  *  @return  void
324  **/
325
326 uint8_t fillUlSchedPucchDedicatedCfg(SchCellCb *cell, SchPucchCfg *pucchDedCfg,\
327    SlotTimingInfo *slotInfo, SchPucchInfo *ulSchedPucch)
328 {
329    uint8_t ret, resrcSetIdx, resrcIdx, schedReqIdx, srPeriodicity = 0;
330    uint16_t srOffset = 0;
331    uint16_t numSlots = cell->numSlots;
332    bool isAllocated = false;
333    uint16_t pucchStartPrb;
334    ret = ROK;
335    if(pucchDedCfg->resrcSet && pucchDedCfg->resrc)
336    {
337       //Assuming one entry in the list
338       for(resrcSetIdx = 0; resrcSetIdx < pucchDedCfg->resrcSet->resrcSetToAddModListCount; resrcSetIdx++)
339       {
340          for(resrcIdx = 0; resrcIdx < pucchDedCfg->resrc->resrcToAddModListCount; resrcIdx++)
341          {
342             if(pucchDedCfg->resrcSet->resrcSetToAddModList[resrcSetIdx].resrcList[resrcSetIdx] ==\
343                   pucchDedCfg->resrc->resrcToAddModList[resrcIdx].resrcId)
344             {
345                ulSchedPucch->intraFreqHop = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].intraFreqHop;
346                ulSchedPucch->secondPrbHop = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].secondPrbHop;
347                ulSchedPucch->fdAlloc.startPrb = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].startPrb;
348                ulSchedPucch->pucchFormat = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].pucchFormat;
349                ret = fillUlSchedPucchFormat(ulSchedPucch->pucchFormat, ulSchedPucch,\
350                      &pucchDedCfg->resrc->resrcToAddModList[resrcIdx], NULLP);
351                if(ret == RFAILED)
352                   return ret;
353
354                pucchStartPrb = pucchDedCfg->resrc->resrcToAddModList[resrcIdx].startPrb;
355                ret = allocatePrbUl(cell, *slotInfo, ulSchedPucch->tdAlloc.startSymb, ulSchedPucch->tdAlloc.numSymb, &pucchStartPrb, PUCCH_NUM_PRB_FORMAT_0_1_4);
356                if(ret == ROK)
357                {
358                   isAllocated = true;
359                   break;
360                }
361             }
362          }
363          if(isAllocated)
364          break;
365       }
366    }
367
368    if(pucchDedCfg->format1)
369    {
370       ret = fillUlSchedPucchFormat(ulSchedPucch->pucchFormat, ulSchedPucch, NULLP, pucchDedCfg->format1);
371       if(ret == RFAILED)
372          return ret;
373    }
374
375    if(!isAllocated)
376    {
377       return RFAILED;
378    }
379
380    /* setting SR and UCI flag */
381    if(pucchDedCfg->schedReq)
382    {
383       for(schedReqIdx = 0; schedReqIdx < pucchDedCfg->schedReq->schedAddModListCount; schedReqIdx++)
384       {
385          srPeriodicity = pucchDedCfg->schedReq->schedAddModList[schedReqIdx].periodicity;
386          srOffset      = pucchDedCfg->schedReq->schedAddModList[schedReqIdx].offset;
387          break;
388       }
389       if(((numSlots * slotInfo->sfn + slotInfo->slot - srOffset) % srPeriodicity) == 0)
390       {
391          ulSchedPucch->srFlag  = true;
392       }
393    }
394    return ret;
395 }
396
397 /**
398  * @brief Function to fill Pucch Resource Info
399  *
400  * @details
401  *
402  *     Function : fillPucchResourceInfo
403  *     
404  *     Function to fill Pucch Resource Info
405  *     
406  *  @param[in]  SchPucchInfo *schPucchInfo, Inst inst
407  *  @return  ROK/RFAILED
408  **/
409
410 uint16_t fillPucchResourceInfo(uint8_t ueId, SchPucchInfo *schPucchInfo, Inst inst, SlotTimingInfo slotInfo)
411 {
412    uint8_t ret = ROK,  ueIdx = 0, pucchIdx = 0;
413    SchCellCb  *cell = schCb[inst].cells[inst];
414    SchPucchCfgCmn *pucchCfg = NULLP;
415    SchBwpParams *ulBwp = NULLP;
416 #ifdef NR_DRX 
417    SchUeCb *ueCb = NULLP;
418 #endif
419    uint16_t startPrb;
420
421    ueIdx = ueId -1;
422 #ifdef NR_DRX 
423    ueCb = &(cell->ueCb[ueIdx]); 
424    if(ueCb->ueDrxInfoPres)
425    {
426       if(!ueCb->drxUeCb.drxUlUeActiveStatus)
427          return RFAILED;
428    }
429 #endif
430    if(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellRecfg.initUlBwp.pucchCfgPres)
431    {
432       /* fill pucch dedicated cfg */
433       ret = fillUlSchedPucchDedicatedCfg(cell,\
434        &cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellRecfg.initUlBwp.pucchCfg, &slotInfo, schPucchInfo);
435       if(ret == RFAILED)
436       {
437          memset(schPucchInfo, 0, sizeof(SchPucchInfo));
438          DU_LOG("\nERROR  --> SCH : Filling PUCCH dedicated cfg failed at fillPucchResourceInfo()");
439          return ret;
440       }
441    }
442    else
443    {
444       /* fill pucch common cfg */
445       /* derive pucchResourceSet from schCellCfg */
446       pucchCfg = &cell->cellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon;
447       pucchIdx = pucchCfg->pucchResourceCommon;
448       ulBwp = &cell->cellCfg.ulCfgCommon.schInitialUlBwp.bwp;
449       startPrb = ulBwp->freqAlloc.startPrb + pucchResourceSet[pucchIdx][3];
450       ret = allocatePrbUl(cell, slotInfo, pucchResourceSet[pucchIdx][1], pucchResourceSet[pucchIdx][2],\
451             &startPrb, PUCCH_NUM_PRB_FORMAT_0_1_4);
452       if (ret == ROK)
453       {
454          schPucchInfo->fdAlloc.startPrb = ulBwp->freqAlloc.startPrb + pucchResourceSet[pucchIdx][3];
455          schPucchInfo->fdAlloc.numPrb = PUCCH_NUM_PRB_FORMAT_0_1_4;
456          schPucchInfo->tdAlloc.startSymb = pucchResourceSet[pucchIdx][1];
457          schPucchInfo->tdAlloc.numSymb = pucchResourceSet[pucchIdx][2];
458          schPucchInfo->pucchFormat = pucchResourceSet[pucchIdx][0];
459
460          /* set SR and UCI flag to false */
461          schPucchInfo->srFlag  = true;
462       }
463    }
464    return ROK;
465 }
466
467 /**
468  * @brief resource allocation for UL
469  *
470  * @details
471  *
472  *     Function : schUlResAlloc
473  *     
474  *     This function handles UL Resource allocation
475  *     
476  *  @param[in]  SchCellCb *cell, cellCb
477  *  @return  void
478  **/
479 uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst)
480 {
481    int ret = ROK;
482 #ifdef NR_DRX 
483    SchUeCb   *ueCb;
484 #endif
485    UlSchedInfo ulSchedInfo;
486    SchUlSlotInfo  *schUlSlotInfo = NULLP;
487    SlotTimingInfo ulTimingInfo;
488    CmLList        *node = NULLP;
489    TotalPrbUsage  *ulTotalPrbUsage = NULLP;
490
491    memset(&ulSchedInfo, 0, sizeof(UlSchedInfo));
492
493    /* add PHY delta */
494    ADD_DELTA_TO_TIME(cell->slotInfo,ulTimingInfo,PHY_DELTA_UL+SCHED_DELTA, cell->numSlots);
495
496    ulSchedInfo.cellId = cell->cellId;
497    ulSchedInfo.slotIndInfo.cellId = ulSchedInfo.cellId;
498    ulSchedInfo.slotIndInfo.sfn = ulTimingInfo.sfn;
499    ulSchedInfo.slotIndInfo.slot = ulTimingInfo.slot;
500
501    /* Schedule resources for PRACH */
502    if(cell->firstSib1Transmitted)
503     schPrachResAlloc(cell, &ulSchedInfo, ulTimingInfo);
504
505    schUlSlotInfo = cell->schUlSlotInfo[ulTimingInfo.slot]; 
506    if(schUlSlotInfo->schPuschInfo)
507    {
508       GET_CRNTI(ulSchedInfo.crnti, schUlSlotInfo->puschUe);
509       /* Check the ue drx status if the UE is active for uplink scheduling or not  */
510 #ifdef NR_DRX 
511       ueCb = schGetUeCb(cell, ulSchedInfo.crnti);
512       if(ueCb->ueDrxInfoPres)
513       {
514          if(!ueCb->drxUeCb.drxUlUeActiveStatus)
515             return RFAILED;
516       }
517 #endif
518       ulSchedInfo.dataType |= SCH_DATATYPE_PUSCH;
519       memcpy(&ulSchedInfo.schPuschInfo, schUlSlotInfo->schPuschInfo,
520             sizeof(SchPuschInfo));
521       SCH_FREE(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo));
522       schUlSlotInfo->schPuschInfo = NULL;
523    }
524
525    if(schUlSlotInfo->pucchPres)
526    {
527       GET_CRNTI(ulSchedInfo.crnti, schUlSlotInfo->pucchUe);
528       ret = fillPucchResourceInfo(schUlSlotInfo->pucchUe, &schUlSlotInfo->schPucchInfo, schInst, ulTimingInfo);
529       if (ret == ROK)
530       {
531          ulSchedInfo.dataType |= SCH_DATATYPE_UCI;
532          memcpy(&ulSchedInfo.schPucchInfo, &schUlSlotInfo->schPucchInfo,
533                sizeof(SchPucchInfo));
534       }
535       else
536       {
537          return RFAILED;
538       }
539       memset(&schUlSlotInfo->schPucchInfo, 0, sizeof(SchPucchInfo));
540    }
541
542    /* Send msg to MAC */
543    ret = sendUlSchInfoToMac(&ulSchedInfo, schInst);
544    if(ret != ROK)
545    {
546       DU_LOG("\nERROR  -->  SCH : Sending UL Sch info from SCH to MAC failed");
547    }
548
549    /* Update DL PRB Usage for all stats group which requested for DL Total PRB Usage */
550    node = cmLListFirst(&schCb[schInst].statistics.activeKpiList.ulTotPrbUseList);
551    while(node)
552    {
553       ulTotalPrbUsage = (TotalPrbUsage *)node->node;
554       ulTotalPrbUsage->numPrbUsedForTx += schUlSlotInfo->prbAlloc.numPrbAlloc;
555       ulTotalPrbUsage->totalPrbAvailForTx += MAX_NUM_RB;
556       node = node->next;
557    }
558
559    /* Re-initialize UL Slot */
560    schInitUlSlot(schUlSlotInfo);
561    return ret;
562 }
563
564 /*******************************************************************
565  *
566  * @brief Fills pdcch and pdsch info for msg4
567  *
568  * @details
569  *
570  *    Function : schDlRsrcAllocMsg4
571  *
572  *    Functionality:
573  *       Fills pdcch and pdsch info for msg4
574  *
575  * @params[in] SchCellCb *cell, SlotTimingInfo msg4Time
576  * @params[in] uint8_t ueId, DlMsgSchInfo *dlMsgAlloc
577  * @params[in] uint8_t pdschStartSymbol, uint8_t pdschNumSymbols
578  * @params[in] bool isRetx, SchDlHqProcCb *hqP
579  * @return ROK     - success
580  *         RFAILED - failure
581  *
582  * ****************************************************************/
583 uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueId, DlMsgSchInfo *dlMsgAlloc,\
584                            uint8_t pdschStartSymbol, uint8_t pdschNumSymbols, bool isRetx, SchDlHqProcCb *hqP)
585 {
586    uint8_t coreset0Idx = 0;
587    uint8_t firstSymbol = 0;
588    uint8_t numSymbols = 0;
589    uint8_t mcs = DEFAULT_MCS;                         /* MCS fixed to 4 */
590    uint8_t dmrsStartSymbol = 0, startSymbol = 0, numSymbol = 0;
591    uint16_t tbSize = 0;
592    uint16_t numRbs;
593    SchBwpDlCfg *initialBwp = NULLP;
594    PdcchCfg *pdcch = NULLP;
595    PdschCfg *pdsch = NULLP;
596    BwpCfg *bwp = NULLP;
597    DlMsgSchInfo *msg4Alloc = NULLP;
598
599    if(cell == NULL)
600    {
601       DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() : Cell is NULL");
602       return RFAILED;
603    }
604
605    if(dlMsgAlloc == NULL)
606    {
607       DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() :  dlMsgAlloc is NULL");
608       return RFAILED;
609    }
610
611    msg4Alloc = dlMsgAlloc;
612    initialBwp   = &cell->cellCfg.dlCfgCommon.schInitialDlBwp;
613    SCH_ALLOC(msg4Alloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
614
615    if(!msg4Alloc->dlMsgPdcchCfg)
616    {
617       DU_LOG("\nERROR  --> SCH : Memory allocation failed in %s",__func__);
618       return RFAILED;
619    }
620    pdcch = msg4Alloc->dlMsgPdcchCfg;
621    bwp = &msg4Alloc->bwp;
622    coreset0Idx  = initialBwp->pdcchCommon.commonSearchSpace.coresetId;
623
624    fillDlMsgInfo(msg4Alloc, cell->raCb[ueId-1].tcrnti, isRetx, hqP);
625    msg4Alloc->dlMsgPduLen = cell->raCb[ueId-1].dlMsgPduLen;
626
627    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
628    numRbs     = coresetIdxTable[coreset0Idx][1];
629    numSymbols = coresetIdxTable[coreset0Idx][2];
630
631    /* calculate time domain parameters */
632    uint16_t mask = 0x2000;
633    for(firstSymbol=0; firstSymbol<MAX_SYMB_PER_SLOT; firstSymbol++)
634    {
635       if(initialBwp->pdcchCommon.commonSearchSpace.monitoringSymbol & mask)
636          break;
637       else
638          mask = mask>>1;
639    }
640
641    /* fill BWP */
642    bwp->freqAlloc.numPrb   = initialBwp->bwp.freqAlloc.numPrb;
643    bwp->freqAlloc.startPrb = initialBwp->bwp.freqAlloc.startPrb;
644    bwp->subcarrierSpacing  = initialBwp->bwp.scs;
645    bwp->cyclicPrefix       = initialBwp->bwp.cyclicPrefix;
646
647    /* fill the PDCCH PDU */
648    pdcch->coresetCfg.startSymbolIndex = firstSymbol;
649    pdcch->coresetCfg.durationSymbols = numSymbols;
650    memcpy(pdcch->coresetCfg.freqDomainResource, \
651       cell->cellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
652
653    pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
654    pdcch->coresetCfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
655    pdcch->coresetCfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
656    pdcch->coresetCfg.coreSetType = 0;
657    pdcch->coresetCfg.coreSetSize = numRbs;
658    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
659    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
660    pdcch->numDlDci = 1;
661    pdcch->dci[0].rnti = cell->raCb[ueId-1].tcrnti;
662    pdcch->dci[0].scramblingId = cell->cellCfg.phyCellId;
663    pdcch->dci[0].scramblingRnti = 0;
664    pdcch->dci[0].cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */
665    pdcch->dci[0].aggregLevel = 4;
666    pdcch->dci[0].beamPdcchInfo.numPrgs = 1;
667    pdcch->dci[0].beamPdcchInfo.prgSize = 1;
668    pdcch->dci[0].beamPdcchInfo.digBfInterfaces = 0;
669    pdcch->dci[0].beamPdcchInfo.prg[0].pmIdx = 0;
670    pdcch->dci[0].beamPdcchInfo.prg[0].beamIdx[0] = 0;
671    pdcch->dci[0].txPdcchPower.beta_pdcch_1_0 = 0;
672    pdcch->dci[0].txPdcchPower.powerControlOffsetSS = 0;
673    pdsch = &pdcch->dci[0].pdschCfg; 
674    
675    /* fill the PDSCH PDU */
676    uint8_t cwCount = 0;
677    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
678    pdsch->rnti = cell->raCb[ueId-1].tcrnti;
679    pdsch->pduIndex = 0;
680    pdsch->numCodewords = 1;
681    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
682    {
683       pdsch->codeword[cwCount].targetCodeRate = 308;
684       pdsch->codeword[cwCount].qamModOrder = 2;
685       pdsch->codeword[cwCount].mcsIndex = mcs; /* mcs configured to 4 */
686       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
687       if(isRetx != TRUE)
688       {
689          tbSize = schCalcTbSize(msg4Alloc->dlMsgPduLen + TX_PAYLOAD_HDR_LEN); /* MSG4 size + FAPI header size*/
690          hqP->tbInfo[cwCount].tbSzReq = tbSize;
691          pdsch->codeword[cwCount].rvIndex = 0;
692       }
693       else
694       {
695          pdsch->codeword[cwCount].rvIndex = (pdsch->codeword[cwCount].rvIndex +1) & 0x03;
696          tbSize = hqP->tbInfo[cwCount].tbSzReq;
697       }
698       pdsch->codeword[cwCount].tbSize = tbSize;
699    }
700    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
701    pdsch->numLayers = 1;
702    pdsch->transmissionScheme = 0;
703    pdsch->refPoint = 0;
704    pdsch->dmrs.dlDmrsSymbPos = DL_DMRS_SYMBOL_POS; 
705    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
706    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
707    pdsch->dmrs.scid = 0;
708    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
709    pdsch->dmrs.dmrsPorts = 0;
710    pdsch->dmrs.mappingType      = DMRS_MAP_TYPE_A; /* Setting to Type-A */
711    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
712    pdsch->dmrs.dmrsAddPos       = DMRS_ADDITIONAL_POS;
713
714    pdsch->pdschTimeAlloc.startSymb = pdschStartSymbol; 
715    pdsch->pdschTimeAlloc.numSymb = pdschNumSymbols;
716
717    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
718    pdsch->pdschFreqAlloc.startPrb = MAX_NUM_RB;
719    pdsch->pdschFreqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, pdschNumSymbols);
720    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
721
722    /* Find total symbols occupied including DMRS */
723    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
724    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
725     * in that case only PDSCH symbols are marked as occupied */
726    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
727    {
728       startSymbol = pdsch->pdschTimeAlloc.startSymb;
729       numSymbol = pdsch->pdschTimeAlloc.numSymb;
730    }
731    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
732    else
733    {
734       startSymbol = dmrsStartSymbol;
735       numSymbol = pdsch->dmrs.nrOfDmrsSymbols + pdsch->pdschTimeAlloc.numSymb;
736    }
737
738    /* Allocate the number of PRBs required for RAR PDSCH */
739    if((allocatePrbDl(cell, msg4Time, startSymbol, numSymbol,\
740       &pdsch->pdschFreqAlloc.startPrb, pdsch->pdschFreqAlloc.numPrb)) != ROK)
741    {
742       DU_LOG("\nERROR  --> SCH : Resource allocation failed for MSG4");
743       SCH_FREE(msg4Alloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
744       return RFAILED;
745    }
746
747    pdsch->beamPdschInfo.numPrgs = 1;
748    pdsch->beamPdschInfo.prgSize = 1;
749    pdsch->beamPdschInfo.digBfInterfaces = 0;
750    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
751    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
752    pdsch->txPdschPower.powerControlOffset = 0;
753    pdsch->txPdschPower.powerControlOffsetSS = 0;
754
755    return ROK;
756 }
757  
758 /*******************************************************************
759  *
760  * @brief Scheduling for Pucch Resource
761  *
762  * @details
763  *
764  *    Function : schAllocPucchResource
765  *
766  *    Functionality:
767  *       Scheduling for Pucch Resource
768  *
769  * @params[in] SchCellCb *cell, SlotTimingInfo pucchTime, crnti
770  * @params[in] SchUeCb *ueCb, bool isRetx, SchDlHqProcCb *hqP
771  * @return ROK     - success
772  *         RFAILED - failure
773  *
774  *******************************************************************/
775
776 uint16_t schAllocPucchResource(SchCellCb *cell, SlotTimingInfo pucchTime, uint16_t crnti,
777                                SchUeCb *ueCb, bool isRetx, SchDlHqProcCb *hqP)
778 {
779    uint16_t pucchSlot = 0;
780    SchUlSlotInfo  *schUlSlotInfo = NULLP;
781
782    pucchSlot = pucchTime.slot;
783    schUlSlotInfo = cell->schUlSlotInfo[pucchSlot];
784    memset(&schUlSlotInfo->schPucchInfo, 0, sizeof(SchPucchInfo));
785
786    schUlSlotInfo->pucchPres = true;
787    if(ueCb != NULLP)
788    {
789       /* set HARQ flag to true */
790       schUlSlotInfo->schPucchInfo.harqInfo.harqBitLength = 1; /* 1 bit for HARQ */
791       ADD_DELTA_TO_TIME(pucchTime, pucchTime, 3, cell->numSlots); /* SLOT_DELAY=3 */
792       cmLListAdd2Tail(&(ueCb->hqDlmap[pucchTime.slot]->hqList), &hqP->ulSlotLnk);
793    }
794    return ROK;
795 }
796
797 /*******************************************************************
798  *
799  * @brief Fills pdcch and pdsch info for dedicated DL msg
800  *
801  * @details
802  *
803  *    Function : schDlRsrcAllocDlMsg
804  *
805  *    Functionality:
806  *       Fills pdcch and pdsch info for dl msg
807  *
808  * @params[in] SchCellCb *cell, SlotTimingInfo slotTime
809  * @params[in] uint16_t crnti, uint32_t tbSize
810  * @params[in] DlMsgSchInfo *dlMsgAlloc, uint16_t startPRB
811  * @params[in] uint8_t pdschStartSymbol, uint8_t pdschNumSymbols
812  * @params[in] bool isRetx, SchDlHqProcCb *hqP
813  * @return ROK     - success
814  *         RFAILED - failure
815  *
816  * ****************************************************************/
817 uint8_t schDlRsrcAllocDlMsg(SchCellCb *cell, SlotTimingInfo slotTime, uint16_t crnti,
818                 uint32_t tbSize, DlMsgSchInfo *dlMsgAlloc, uint16_t startPRB, uint8_t pdschStartSymbol,
819                 uint8_t pdschNumSymbols, bool isRetx, SchDlHqProcCb *hqP, SchPdcchAllocInfo pdcchAllocInfo)
820 {
821    uint8_t ueId=0, ssIdx = 0, cRSetIdx = 0;;
822    uint8_t cwCount = 0, rbgCount = 0, pdcchStartSymbol = 0;
823    PdcchCfg *pdcch = NULLP;
824    PdschCfg *pdsch = NULLP;
825    BwpCfg *bwp = NULLP;
826    SchUeCb ueCb;
827    SchControlRsrcSet coreset1;
828    SchSearchSpace searchSpace;
829    SchPdschConfig pdschCfg;
830    uint8_t dmrsStartSymbol, startSymbol, numSymbol;
831
832    SCH_ALLOC(dlMsgAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
833    if(!dlMsgAlloc->dlMsgPdcchCfg)
834    {
835       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schDlRsrcAllocDlMsg");
836       return RFAILED;
837    }
838    pdcch = dlMsgAlloc->dlMsgPdcchCfg;
839    bwp = &dlMsgAlloc->bwp;
840
841    GET_UE_ID(crnti, ueId);
842    ueCb  = cell->ueCb[ueId-1];
843
844    for(cRSetIdx = 0; cRSetIdx < ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.numCRsetToAddMod; cRSetIdx++)
845    {
846       if(ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.cRSetToAddModList[cRSetIdx].cRSetId\
847             == pdcchAllocInfo.cRSetId)
848       {
849          coreset1 = ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.cRSetToAddModList[cRSetIdx];
850          break;
851       }
852    }
853    for(ssIdx = 0; ssIdx < ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.numSearchSpcToAddMod; ssIdx++)
854    {
855       if(ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.searchSpcToAddModList[ssIdx].searchSpaceId\
856             ==  pdcchAllocInfo.ssId)
857       {
858          searchSpace = ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg.searchSpcToAddModList[ssIdx];
859          break;
860       }
861    }
862    pdschCfg = ueCb.ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdschCfg;
863
864    /* fill BWP */
865    bwp->freqAlloc.numPrb = MAX_NUM_RB;
866    bwp->freqAlloc.startPrb = 0;
867    bwp->subcarrierSpacing = cell->sib1SchCfg.bwp.subcarrierSpacing;
868    bwp->cyclicPrefix = cell->sib1SchCfg.bwp.cyclicPrefix;
869
870    /* fill the PDCCH PDU */
871    /*StartSymbol of PDCCH*/
872    pdcchStartSymbol = findSsStartSymbol(searchSpace.mSymbolsWithinSlot);
873    if(pdcchStartSymbol < MAX_SYMB_PER_SLOT)
874       pdcch->coresetCfg.startSymbolIndex = pdcchStartSymbol;
875    else
876    {
877       DU_LOG("\nERROR  -->  SCH : Invalid SymbolIndex in schDlRsrcAllocDlMsg");
878       return RFAILED;
879    }
880    pdcch->coresetCfg.durationSymbols = coreset1.duration;
881    memcpy(pdcch->coresetCfg.freqDomainResource, coreset1.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
882    pdcch->coresetCfg.cceRegMappingType = coreset1.cceRegMappingType; /* non-interleaved */
883    pdcch->coresetCfg.regBundleSize = 6;   /* must be 6 for non-interleaved */
884    pdcch->coresetCfg.interleaverSize = 0; /* NA for non-interleaved */
885    pdcch->coresetCfg.coreSetType = 1; /* non PBCH coreset */
886
887    /*Size of coreset: Number of PRBs in a coreset*/
888    rbgCount = countRBGFrmCoresetFreqRsrc(coreset1.freqDomainRsrc);
889    if(rbgCount)
890    {
891       pdcch->coresetCfg.coreSetSize = ((rbgCount) * NUM_PRBS_PER_RBG);
892    }
893    else
894    {
895       DU_LOG("\nERROR  -->  SCH : CORESETSize is zero in schDlRsrcAllocDlMsg");
896       return RFAILED;
897    }
898
899    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
900    pdcch->coresetCfg.precoderGranularity =  coreset1.precoderGranularity;
901    if(pdcch->numDlDci >= MAX_NUM_PDCCH)
902    {
903       DU_LOG("\nERROR  -->  SCH: MAX number of PDCCH allocted for this slot.");
904       return RFAILED;
905    }
906    pdcch->dci[pdcch->numDlDci].rnti = ueCb.crnti;
907    pdcch->dci[pdcch->numDlDci].scramblingId = cell->cellCfg.phyCellId;
908    pdcch->dci[pdcch->numDlDci].scramblingRnti = 0;
909
910    /*TODO below assumptions of CCE Index is wrong:
911     * Range 0 to 135 as per ORAN.WG8.AAD Table 9-35 CORESET configuration and
912     * it has to be calculated using the formula given in 3GPP TS 38.213, Sec 10.1 */
913    pdcch->dci[pdcch->numDlDci].cceIndex = pdcchAllocInfo.cceIndex; 
914    pdcch->dci[pdcch->numDlDci].aggregLevel = pdcchAllocInfo.aggLvl;
915    pdcch->dci[pdcch->numDlDci].beamPdcchInfo.numPrgs = 1;
916    pdcch->dci[pdcch->numDlDci].beamPdcchInfo.prgSize = 1;
917    pdcch->dci[pdcch->numDlDci].beamPdcchInfo.digBfInterfaces = 0;
918    pdcch->dci[pdcch->numDlDci].beamPdcchInfo.prg[0].pmIdx = 0;
919    pdcch->dci[pdcch->numDlDci].beamPdcchInfo.prg[0].beamIdx[0] = 0;
920    pdcch->dci[pdcch->numDlDci].txPdcchPower.beta_pdcch_1_0 = 0;
921    pdcch->dci[pdcch->numDlDci].txPdcchPower.powerControlOffsetSS = 0;
922
923    pdsch = &pdcch->dci[pdcch->numDlDci].pdschCfg;
924    pdcch->numDlDci++;
925
926    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
927    pdsch->rnti = ueCb.crnti;
928    pdsch->pduIndex = 0;
929    pdsch->numCodewords = 1;
930    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
931    {
932       pdsch->codeword[cwCount].targetCodeRate = 308;
933       pdsch->codeword[cwCount].qamModOrder = ueCb.ueCfg.dlModInfo.modOrder;
934       pdsch->codeword[cwCount].mcsIndex = ueCb.ueCfg.dlModInfo.mcsIndex;
935       pdsch->codeword[cwCount].mcsTable = ueCb.ueCfg.dlModInfo.mcsTable;
936       pdsch->codeword[cwCount].rvIndex = 0;
937
938       if (isRetx != TRUE)
939       {
940          tbSize +=TX_PAYLOAD_HDR_LEN;
941          hqP->tbInfo[cwCount].tbSzReq = tbSize;
942       }
943       pdsch->codeword[cwCount].tbSize = tbSize;
944    }
945    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
946    pdsch->numLayers = 1;
947    pdsch->transmissionScheme = 0;
948    pdsch->refPoint = 0;
949    pdsch->dmrs.dlDmrsSymbPos = DL_DMRS_SYMBOL_POS; 
950    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
951    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
952    pdsch->dmrs.scid = 0;
953    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
954    pdsch->dmrs.dmrsPorts = 0;
955    pdsch->dmrs.mappingType      = DMRS_MAP_TYPE_A; /* Setting to Type-A */
956    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
957    pdsch->dmrs.dmrsAddPos       = pdschCfg.dmrsDlCfgForPdschMapTypeA.addPos;
958
959    pdsch->pdschTimeAlloc.startSymb = pdschStartSymbol; 
960    pdsch->pdschTimeAlloc.numSymb = pdschNumSymbols;
961
962    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
963    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
964    pdsch->pdschFreqAlloc.startPrb = startPRB; /*Start PRB will be already known*/
965    pdsch->pdschFreqAlloc.numPrb = schCalcNumPrb(tbSize, ueCb.ueCfg.dlModInfo.mcsIndex, pdschNumSymbols);
966
967    /* Find total symbols occupied including DMRS */
968    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
969    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
970     * in that case only PDSCH symbols are marked as occupied */
971    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
972    {
973       startSymbol = pdsch->pdschTimeAlloc.startSymb;
974       numSymbol = pdsch->pdschTimeAlloc.numSymb;
975    }
976    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
977    else
978    {
979       startSymbol = dmrsStartSymbol;
980       numSymbol = pdsch->dmrs.nrOfDmrsSymbols + pdsch->pdschTimeAlloc.numSymb;
981    }
982
983    /* Allocate the number of PRBs required for DL PDSCH */
984    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
985                &pdsch->pdschFreqAlloc.startPrb, pdsch->pdschFreqAlloc.numPrb)) != ROK)
986    {
987       DU_LOG("\nERROR  --> SCH : allocatePrbDl() failed for DL MSG");
988       SCH_FREE(dlMsgAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
989       return RFAILED;
990    }
991
992    pdsch->beamPdschInfo.numPrgs = 1;
993    pdsch->beamPdschInfo.prgSize = 1;
994    pdsch->beamPdschInfo.digBfInterfaces = 0;
995    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
996    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
997    pdsch->txPdschPower.powerControlOffset = 0;
998    pdsch->txPdschPower.powerControlOffsetSS = 0;
999
1000    return ROK;
1001 }
1002
1003 /*******************************************************************
1004  *
1005  * @brief Fills k0 and k1 information table for FDD 
1006  *
1007  * @details
1008  *
1009  *    Function : BuildK0K1TableForFdd 
1010  *
1011  *    Functionality:
1012  *      Fills k0 and k1 information table for FDD
1013  *
1014  * @params[in] SchCellCb *cell,SchK0K1TimingInfoTbl *k0K1InfoTbl,bool
1015  * pdschCfgCmnPres,uint8_t numTimeDomAlloc, SchPdschCfgCmnTimeDomRsrcAlloc
1016  * cmnTimeDomRsrcAllocList[], SchPdschTimeDomRsrcAlloc
1017  * dedTimeDomRsrcAllocList[], uint8_t ulAckListCount, uint8_t *UlAckTbl
1018  * @return ROK     - success
1019  *         RFAILED - failure
1020  *
1021  * ****************************************************************/
1022 void BuildK0K1TableForFdd(SchCellCb *cell, SchK0K1TimingInfoTbl *k0K1InfoTbl, bool pdschCfgCmnPres,SchPdschCfgCmn pdschCmnCfg,\
1023 SchPdschConfig pdschDedCfg, uint8_t ulAckListCount, uint8_t *UlAckTbl)
1024 {
1025    
1026    uint8_t k1TmpVal =0, cfgIdx=0;
1027    uint8_t slotIdx=0, k0Index=0, k1Index=0, numK0=0, numK1=0, numTimeDomAlloc=0;
1028    
1029    /* TODO Commented these below lines for resolving warnings. Presently these variable are not 
1030     * required but this will require for harq processing */
1031    // uint8_t k0TmpVal = 0; 
1032    // SchPdschCfgCmnTimeDomRsrcAlloc cmnTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
1033    // SchPdschTimeDomRsrcAlloc dedTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
1034
1035    /* Initialization the structure and storing the total slot values. */
1036    memset(k0K1InfoTbl, 0, sizeof(SchK0K1TimingInfoTbl));
1037    k0K1InfoTbl->tblSize = cell->numSlots;
1038    
1039    /* Storing time domain resource allocation list based on common or dedicated configuration. */
1040    if(pdschCfgCmnPres == true)
1041    {
1042       numTimeDomAlloc = pdschCmnCfg.numTimeDomAlloc;
1043       for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1044       {
1045          /*TODO uncomment this line during harq processing */
1046          //cmnTimeDomRsrcAllocList[cfgIdx] = pdschCmnCfg.timeDomRsrcAllocList[cfgIdx];
1047       }
1048    }
1049    else
1050    {
1051       numTimeDomAlloc = pdschDedCfg.numTimeDomRsrcAlloc;
1052       for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1053       {
1054          /*TODO uncomment this line during harq processing */
1055          //dedTimeDomRsrcAllocList[cfgIdx] = pdschDedCfg.timeDomRsrcAllociList[cfgIdx];
1056       }
1057    }
1058    
1059    /* Checking all the slots for K0 and K1 values. */
1060    for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1061    {
1062       numK0 = 0;
1063       /* Storing the values of k0 based on time domain resource
1064        * allocation list. If the value is unavailable then fill default values,
1065        * As per 38.331 PDSCH-TimeDomainResourceAllocation field descriptions. */
1066       for(k0Index = 0; ((k0Index < numTimeDomAlloc) && (k0Index < MAX_NUM_K0_IDX));  k0Index++)
1067       {
1068          /* TODO These if 0 we will remove during harq processing */
1069 #if 0
1070          if(pdschCfgCmnPres == true)
1071          {
1072             k0TmpVal = cmnTimeDomRsrcAllocList[k0Index].k0;
1073          }
1074          else
1075          {
1076             if(dedTimeDomRsrcAllocList[k0Index].k0 != NULLP)
1077             {
1078                k0TmpVal = *(dedTimeDomRsrcAllocList[k0Index].k0);
1079             }
1080             else
1081             { 
1082                k0TmpVal = DEFAULT_K0_VALUE;
1083             }
1084          }
1085 #endif         
1086          /* Checking all the Ul Alloc values. If value is less than MIN_NUM_K1_IDX
1087           * then skip else continue storing the values. */
1088          numK1 = 0;
1089          for(k1Index = 0; k1Index < ulAckListCount; k1Index++)
1090          {
1091             k1TmpVal = UlAckTbl[k1Index];
1092             if(k1TmpVal <= MIN_NUM_K1_IDX)
1093             {
1094                continue;
1095             }
1096
1097             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.k1Indexes[numK1++] = k1Index;
1098             /* TODO Store K1 index where harq feedback will be received in harq table. */ 
1099          }
1100          if(numK1)
1101          {
1102             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.numK1 = numK1;
1103             k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k0Index = k0Index;
1104             numK0++;
1105          }
1106       }
1107       if(numK0)
1108       {
1109          k0K1InfoTbl->k0k1TimingInfo[slotIdx].numK0 = numK0;
1110       }
1111    }
1112 }
1113
1114 /*******************************************************************
1115  *
1116  * @brief Fills k0 and k1 information table  
1117  *
1118  * @details
1119  *
1120  *    Function : BuildK0K1Table
1121  *
1122  *    Functionality:
1123  *       Fills K0 and k1 information table 
1124  *
1125  * @params[in] SchCellCb *cell,SchK0K1TimingInfoTbl *k0K1InfoTbl,bool
1126  * pdschCfgCmnPres,uint8_t numTimeDomAlloc, SchPdschCfgCmnTimeDomRsrcAlloc
1127  * cmnTimeDomRsrcAllocList[], SchPdschTimeDomRsrcAlloc
1128  * dedTimeDomRsrcAllocList[], uint8_t ulAckListCount, uint8_t *UlAckTbl
1129  * @return ROK     - success
1130  *         RFAILED - failure
1131  *
1132  * ****************************************************************/
1133 void BuildK0K1Table(SchCellCb *cell, SchK0K1TimingInfoTbl *k0K1InfoTbl, bool pdschCfgCmnPres, SchPdschCfgCmn pdschCmnCfg,\
1134 SchPdschConfig pdschDedCfg, uint8_t ulAckListCount, uint8_t *UlAckTbl)
1135 {
1136
1137 #ifdef NR_TDD
1138    SlotConfig  slotCfg;
1139    bool ulSlotPresent = false;
1140    uint8_t k0TmpVal = 0, k1TmpVal =0, tmpSlot=0, startSymbol=0, endSymbol=0, checkSymbol=0;
1141    uint8_t slotIdx=0, k0Index=0, k1Index=0, numK0=0, numK1=0, cfgIdx=0, numTimeDomAlloc =0, totalCfgSlot =0;
1142    SchPdschCfgCmnTimeDomRsrcAlloc cmnTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
1143    SchPdschTimeDomRsrcAlloc dedTimeDomRsrcAllocList[MAX_NUM_DL_ALLOC];
1144 #endif
1145
1146    if(cell->cellCfg.dupMode == DUPLEX_MODE_FDD)
1147    {
1148       BuildK0K1TableForFdd(cell, k0K1InfoTbl, pdschCfgCmnPres, pdschCmnCfg, pdschDedCfg, ulAckListCount, UlAckTbl);
1149    }
1150    else
1151    {
1152 #ifdef NR_TDD
1153       
1154       /* Initialization the K0K1 structure, total num of slot and calculating the slot pattern length. */
1155       memset(k0K1InfoTbl, 0, sizeof(SchK0K1TimingInfoTbl));
1156       k0K1InfoTbl->tblSize = cell->numSlots;
1157       totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbScs, cell->cellCfg.tddCfg.tddPeriod);
1158       
1159       /* Storing time domain resource allocation list based on common or 
1160        * dedicated configuration availability. */
1161       if(pdschCfgCmnPres == true)
1162       {
1163          numTimeDomAlloc = pdschCmnCfg.numTimeDomAlloc;
1164          for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1165          {
1166             cmnTimeDomRsrcAllocList[cfgIdx] = pdschCmnCfg.timeDomRsrcAllocList[cfgIdx];
1167          }
1168       }
1169       else
1170       {
1171          numTimeDomAlloc = pdschDedCfg.numTimeDomRsrcAlloc;
1172          for(cfgIdx = 0; cfgIdx<numTimeDomAlloc; cfgIdx++)
1173          {
1174             dedTimeDomRsrcAllocList[cfgIdx] = pdschDedCfg.timeDomRsrcAllociList[cfgIdx];
1175          }
1176       }
1177
1178       /* Checking all possible indexes for K0 and K1 values. */
1179       for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1180       {
1181          /* If current slot is UL or FLEXI then Skip because PDCCH is sent only in DL slots. */
1182          slotCfg = schGetSlotSymbFrmt(slotIdx%totalCfgSlot, cell->slotFrmtBitMap);
1183          if(slotCfg == UL_SLOT || slotCfg == FLEXI_SLOT)
1184          {
1185             continue;
1186          }
1187         
1188          ulSlotPresent = false;
1189          /* Storing K0 , start symbol and length symbol for further processing.
1190           * If K0 value is not available then we can fill the default values
1191           * given in spec 38.331. */
1192          numK0 = 0;
1193          for(k0Index = 0; ((k0Index < numTimeDomAlloc) && (k0Index < MAX_NUM_K0_IDX)); k0Index++)
1194          {
1195             if(pdschCfgCmnPres == true)
1196             {
1197                k0TmpVal = cmnTimeDomRsrcAllocList[k0Index].k0;
1198                startSymbol = cmnTimeDomRsrcAllocList[k0Index].startSymbol;
1199                endSymbol = startSymbol + cmnTimeDomRsrcAllocList[k0Index].lengthSymbol;
1200             }
1201             else
1202             {
1203                if(dedTimeDomRsrcAllocList[k0Index].k0 != NULLP)
1204                {
1205                   k0TmpVal =  *(dedTimeDomRsrcAllocList[k0Index].k0);
1206                }
1207                else
1208                {
1209                   k0TmpVal = DEFAULT_K0_VALUE;
1210                }
1211                startSymbol = dedTimeDomRsrcAllocList[k0Index].startSymbol;
1212                endSymbol = startSymbol + dedTimeDomRsrcAllocList[k0Index].symbolLength;
1213             }
1214             
1215             /* If current slot + k0 is UL then skip the slot
1216              * else if it is DL slot then continue the next steps
1217              * else if it is a FLEXI slot then check symbols of slot, It should not
1218              * contain any UL slot. */
1219             tmpSlot = (slotIdx+k0TmpVal) % totalCfgSlot;
1220             slotCfg = schGetSlotSymbFrmt(tmpSlot, cell->slotFrmtBitMap);
1221             if(slotCfg == UL_SLOT)
1222             {
1223                continue;
1224             }
1225             if(slotCfg == FLEXI_SLOT)
1226             {
1227                for(checkSymbol = startSymbol; checkSymbol<endSymbol; checkSymbol ++)
1228                {
1229                   slotCfg = cell->slotCfg[tmpSlot][checkSymbol];
1230                   if(slotCfg == UL_SLOT)
1231                   {
1232                      ulSlotPresent = true;
1233                      break;
1234                   }
1235                }
1236                if(ulSlotPresent == true)
1237                {
1238                   continue;
1239                }
1240             }
1241
1242              ulSlotPresent = false; //Re-initializing
1243
1244             /* If current slot + k0 + k1 is a DL slot then skip the slot
1245              * else if it is UL slot then store the information 
1246              * else if it is FLEXI slot then check the symbols, it must have
1247              * at least one UL symbol. */
1248             numK1 = 0;
1249             for(k1Index = 0; k1Index < ulAckListCount; k1Index++)
1250             {
1251                k1TmpVal = UlAckTbl[k1Index];
1252                if(k1TmpVal > MIN_NUM_K1_IDX)
1253                {
1254                   tmpSlot = (slotIdx+k0TmpVal+k1TmpVal) % totalCfgSlot;
1255                   slotCfg =  schGetSlotSymbFrmt(tmpSlot, cell->slotFrmtBitMap);
1256                   if(slotCfg == DL_SLOT) 
1257                   {
1258                      continue;
1259                   }   
1260                   if(slotCfg == FLEXI_SLOT)
1261                   {
1262                      for(checkSymbol = 0; checkSymbol< MAX_SYMB_PER_SLOT;checkSymbol++)
1263                      {
1264                         if(cell->slotCfg[tmpSlot][checkSymbol] == UL_SYMBOL)
1265                         {
1266                            ulSlotPresent = true;
1267                            break;
1268                         }
1269                      }
1270                   }
1271                   if(ulSlotPresent == true || slotCfg ==  UL_SLOT)
1272                   {
1273                      k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.k1Indexes[numK1++] = k1Index;
1274                      /* TODO Store K1 index where harq feedback will be received
1275                       * in harq table. */
1276                   }
1277                }
1278             }
1279             
1280             /* Store all the values if all condition satisfies. */
1281             if(numK1)
1282             {
1283                k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k1TimingInfo.numK1 = numK1;
1284                k0K1InfoTbl->k0k1TimingInfo[slotIdx].k0Indexes[numK0].k0Index = k0Index;
1285                numK0++;
1286             }
1287          }
1288          if(numK0)
1289          {
1290             k0K1InfoTbl->k0k1TimingInfo[slotIdx].numK0 = numK0;
1291          }
1292       }
1293 #endif
1294    }
1295 }
1296
1297 /*******************************************************************
1298 *
1299 * @brief Fills K2 information table for FDD
1300 *
1301 * @details
1302 *
1303 *    Function : BuildK2InfoTableForFdd 
1304 *
1305 *    Functionality:
1306 *       Fills K2 information table for FDD
1307 *
1308 * @params[in] SchCellCb *cell,SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[],
1309 * uint16_t puschSymTblSize,SchK2TimingInfoTbl *k2InfoTbl
1310 * @return ROK     - success
1311 *         RFAILED - failure
1312 *
1313 * ****************************************************************/
1314 void BuildK2InfoTableForFdd(SchCellCb *cell, SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[], uint16_t puschSymTblSize,\
1315 SchK2TimingInfoTbl *msg3K2InfoTbl, SchK2TimingInfoTbl *k2InfoTbl)
1316 {
1317    uint16_t slotIdx=0, k2Index=0, k2TmpIdx=0, msg3K2TmpIdx=0;
1318
1319    /* Initialization the structure and storing the total slot values. */
1320    memset(k2InfoTbl, 0, sizeof(SchK2TimingInfoTbl));
1321    k2InfoTbl->tblSize = cell->numSlots;
1322    if(msg3K2InfoTbl)
1323       msg3K2InfoTbl->tblSize = cell->numSlots;
1324    
1325    /* Checking all possible indexes for K2. */
1326    for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1327    {
1328       /* Storing K2 values. */
1329       for(k2Index = 0; ((k2Index < puschSymTblSize) && (k2Index < MAX_NUM_K2_IDX)); k2Index++)
1330       {
1331          k2TmpIdx= k2InfoTbl->k2TimingInfo[slotIdx].numK2;
1332          k2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[k2TmpIdx] = k2Index;
1333          k2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1334
1335          /* Updating K2 values for MSG3 */
1336          if(msg3K2InfoTbl)
1337          {
1338             msg3K2TmpIdx = msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2;
1339             msg3K2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[msg3K2TmpIdx] = k2Index;
1340             msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1341          }
1342       }
1343    }
1344 }
1345
1346 /*******************************************************************
1347  *
1348  * @brief Fills K2 information table
1349  *
1350  * @details
1351  *
1352  *    Function : BuildK2InfoTable 
1353  *
1354  *    Functionality:
1355  *       Fills K2 information table
1356  *
1357  * @params[in] SchCellCb *cell,SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[],
1358  * uint16_t puschSymTblSize, SchK2TimingInfoTbl *k2InfoTbl
1359  * @return ROK     - success
1360  *         RFAILED - failure
1361  *
1362  * ****************************************************************/
1363 void BuildK2InfoTable(SchCellCb *cell, SchPuschTimeDomRsrcAlloc timeDomRsrcAllocList[], uint16_t puschSymTblSize,\
1364 SchK2TimingInfoTbl *msg3K2InfoTbl, SchK2TimingInfoTbl *k2InfoTbl)
1365 {
1366
1367 #ifdef NR_TDD
1368    bool dlSymbolPresent = false;
1369    uint8_t slotIdx=0, k2Index=0, k2Val=0, k2TmpVal=0, msg3K2TmpVal=0, msg3Delta=0, numK2 =0, currentSymbol =0;
1370    uint8_t startSymbol =0, endSymbol =0, checkSymbol=0, totalCfgSlot=0, slotCfg=0;
1371    SlotConfig currentSlot;
1372 #endif
1373
1374    if(cell->cellCfg.dupMode == DUPLEX_MODE_FDD)
1375    {
1376       BuildK2InfoTableForFdd(cell, timeDomRsrcAllocList, puschSymTblSize, msg3K2InfoTbl, k2InfoTbl);
1377    }
1378    else
1379    {
1380 #ifdef NR_TDD
1381
1382       /* Initialization the structure and storing the total slot values. */
1383       memset(k2InfoTbl, 0, sizeof(SchK2TimingInfoTbl));
1384       k2InfoTbl->tblSize = cell->numSlots;
1385       if(msg3K2InfoTbl)
1386          msg3K2InfoTbl->tblSize = cell->numSlots;
1387       totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbScs, cell->cellCfg.tddCfg.tddPeriod);
1388
1389       /* Checking all possible indexes for K2. */
1390       for(slotIdx = 0; slotIdx < cell->numSlots; slotIdx++)
1391       {
1392          currentSlot = schGetSlotSymbFrmt(slotIdx % totalCfgSlot, cell->slotFrmtBitMap);
1393          
1394          /* If current slot is UL then skip because PDCCH is sent only in DL slots */
1395          if(currentSlot != UL_SLOT)
1396          {
1397             for(k2Index = 0; ((k2Index < puschSymTblSize) && (k2Index < MAX_NUM_K2_IDX)); k2Index++)
1398             {
1399                /* Storing k2, startSymbol, endSymbol information for further processing.
1400                 * If k2 is absent then fill the default values given in spec 38.331
1401                 * PUSCH-TimeDomainResourceAllocationList field descriptions */
1402                k2Val = timeDomRsrcAllocList[k2Index].k2;
1403                if(!k2Val)
1404                {
1405                   switch(cell->cellCfg.ssbScs)
1406                   {
1407                      case SCS_15KHZ:
1408                         k2Val = DEFAULT_K2_VALUE_FOR_SCS15;
1409                         break;
1410                      case SCS_30KHZ:
1411                         k2Val = DEFAULT_K2_VALUE_FOR_SCS30;
1412                         break;
1413                      case SCS_60KHZ:
1414                         k2Val = DEFAULT_K2_VALUE_FOR_SCS60;
1415                         break;
1416                      case SCS_120KHZ:
1417                         k2Val = DEFAULT_K2_VALUE_FOR_SCS120;
1418                         break;
1419                   }
1420                }
1421                
1422                /* Current slot + k2 should be either UL or FLEXI slot.
1423                 * If slot is FLEXI then check all the symbols of that slot,
1424                 * it should not contain any DL or FLEXI slot */
1425                k2TmpVal = (slotIdx + k2Val) % totalCfgSlot;
1426                slotCfg = schGetSlotSymbFrmt(k2TmpVal, cell->slotFrmtBitMap);
1427                if(slotCfg != DL_SLOT)
1428                {
1429                   if(slotCfg == FLEXI_SLOT)
1430                   {
1431                      startSymbol =  timeDomRsrcAllocList[k2Index].startSymbol;
1432                      endSymbol   =  startSymbol+ timeDomRsrcAllocList[k2Index].symbolLength;
1433                      dlSymbolPresent = false;
1434                      for(checkSymbol= startSymbol; checkSymbol<endSymbol; checkSymbol++)
1435                      {
1436                         currentSymbol = cell->slotCfg[k2TmpVal][checkSymbol];
1437                         if(currentSymbol == DL_SLOT || currentSymbol == FLEXI_SLOT)
1438                         {
1439                            dlSymbolPresent = true;
1440                            break;
1441                         }
1442                      }
1443                   }
1444                   /* Store all the values if all condition satisfies. */
1445                   if(dlSymbolPresent != true || slotCfg == UL_SLOT)
1446                   {
1447                      numK2 = k2InfoTbl->k2TimingInfo[slotIdx].numK2;
1448                      k2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[numK2] = k2Index;
1449                      k2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1450                   }
1451                }
1452
1453                if(msg3K2InfoTbl)
1454                {
1455                    msg3Delta = puschDeltaTable[cell->numerology];
1456
1457                   /* Check for K2 for MSG3 */
1458                   /* Current slot + k2 should be either UL or FLEXI slot.
1459                    * If slot is FLEXI then check all the symbols of that slot,
1460                    * it should not contain any DL or FLEXI slot */
1461                   msg3K2TmpVal = (slotIdx + k2Val + msg3Delta) % totalCfgSlot;
1462                   slotCfg = schGetSlotSymbFrmt(msg3K2TmpVal, cell->slotFrmtBitMap);
1463                   if(slotCfg != DL_SLOT)
1464                   {
1465                      if(slotCfg == FLEXI_SLOT)
1466                      {
1467                         startSymbol =  timeDomRsrcAllocList[k2Index].startSymbol;
1468                         endSymbol   =  startSymbol+ timeDomRsrcAllocList[k2Index].symbolLength;
1469                         dlSymbolPresent = false;
1470                         for(checkSymbol= startSymbol; checkSymbol<endSymbol; checkSymbol++)
1471                         {
1472                            currentSymbol = cell->slotCfg[msg3K2TmpVal][checkSymbol];
1473                            if(currentSymbol == DL_SLOT || currentSymbol == FLEXI_SLOT)
1474                            {
1475                               dlSymbolPresent = true;
1476                               break;
1477                            }
1478                         }
1479                      }
1480                      /* Store all the values if all condition satisfies. */
1481                      if(dlSymbolPresent != true || slotCfg == UL_SLOT)
1482                      {
1483                         numK2 = msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2;
1484                         msg3K2InfoTbl->k2TimingInfo[slotIdx].k2Indexes[numK2] = k2Index;
1485                         msg3K2InfoTbl->k2TimingInfo[slotIdx].numK2++;
1486                      }
1487                   }
1488                }
1489             }
1490          }
1491       }
1492 #endif
1493    }
1494 }
1495
1496 /*******************************************************************************************
1497  *
1498  * @brief Allocate the PRB using RRM policy
1499  *
1500  * @details
1501  *
1502  *    Function : prbAllocUsingRRMPolicy
1503  *
1504  *    Functionality:
1505  *      [Step1]: Traverse each Node in the LC list
1506  *      [Step2]: Check whether the LC has ZERO requirement then clean this LC
1507  *      [Step3]: Calcualte the maxPRB for this LC.
1508  *              a. For Dedicated LC, maxPRB = sum of remainingReservedPRB and
1509  *              sharedPRB
1510  *              b. For Default, just SharedPRB count
1511  *      [Step4]: If the LC is the First one to be allocated for this UE then add
1512  *      TX_PAYLODN_LEN to reqBO 
1513  *      [Step5]: Calculate the estimate PRB and estimate BO to be allocated
1514  *               based on reqBO and maxPRB left.
1515  *      [Step6]: Based on calculated PRB, Update Reserved PRB and Shared PRB counts
1516  *      [Step7]: Deduce the reqBO based on allocBO and move the LC node to last.
1517  *      [Step8]: Continue the next loop from List->head
1518  *
1519  *      [Loop Exit]:
1520  *        [Exit1]: If all the LCs are allocated in list
1521  *        [Exit2]: If PRBs are exhausted
1522  *
1523  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1524  *             I/P > IsDedicatedPRB (Flag to indicate that RESERVED PRB to use 
1525  *             I/P > mcsIdx and PDSCH symbols count 
1526  *             I/P & O/P > Shared PRB , reserved PRB Count
1527  *             I/P & O/P > Total TBS size accumulated
1528  *             I/P & O/P > isTxPayloadLenAdded[For DL] : Decision flag to add the TX_PAYLOAD_HDR_LEN
1529  *             I/P & O/P > srRcvd Flag[For UL] : Decision flag to add UL_GRANT_SIZE
1530  *
1531  * @return void
1532  *
1533  * *******************************************************************************************/
1534 void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsIdx,uint8_t numSymbols,\
1535                   uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded, bool *srRcvd)
1536 {
1537    CmLList *node = NULLP;
1538    LcInfo *lcNode = NULLP;
1539    uint16_t remReservedPRB = 0, estPrb = 0, maxPRB = 0;
1540
1541    if(lcLL == NULLP)
1542    {
1543       DU_LOG("\nERROR --> SCH: LcList not present");
1544       return;
1545    }
1546    node = lcLL->first;
1547
1548    /*Only for Dedicated LcList, Valid value will be assigned to remReservedPRB
1549     * For Other LcList, remReservedPRB = 0*/
1550    if(reservedPRB != NULLP && isDedicatedPRB == TRUE)
1551    {
1552       remReservedPRB = *reservedPRB;
1553    }
1554
1555    /*[Step1]*/
1556    while(node)
1557    {
1558 #if 0
1559       /*For Debugging purpose*/
1560       printLcLL(lcLL);
1561 #endif
1562       lcNode = (LcInfo *)node->node;
1563
1564       /* [Step2]: Below condition will hit in rare case as it has been taken care during the cleaning 
1565        * process of LCID which was fully allocated. Check is just for safety purpose*/
1566       if(lcNode->reqBO == 0 && lcNode->allocBO == 0)
1567       {
1568          DU_LOG("\nERROR --> SCH: LCID:%d has no requirement, clearing this node",\
1569                lcNode->lcId);
1570          deleteNodeFromLList(lcLL, node);
1571          SCH_FREE(lcNode, sizeof(LcInfo));
1572          node = lcLL->first; 
1573          continue;
1574       }
1575
1576       /*[Exit1]: All LCs are allocated(allocBO = 0 for fully unallocated LC)*/
1577       if(lcNode->allocBO != 0)
1578       {
1579          DU_LOG("\nDEBUG  -->  SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB);
1580          return;
1581       }
1582
1583       /*[Exit2]: If PRBs are exhausted*/
1584       if(isDedicatedPRB)
1585       {
1586          /*Loop Exit: All resources exhausted*/
1587          if(remReservedPRB == 0 && *sharedPRB == 0)
1588          {
1589             DU_LOG("\nDEBUG  -->  SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId);
1590             return;
1591          }
1592       }
1593       else
1594       {
1595          /*Loop Exit: All resources exhausted*/
1596          if(*sharedPRB == 0)
1597          {
1598             DU_LOG("\nDEBUG  -->  SCH: Default resources exhausted for LC:%d",lcNode->lcId);
1599             return;
1600          }
1601       }
1602
1603       /*[Step3]*/
1604       maxPRB = remReservedPRB + *sharedPRB;
1605
1606       /*[Step4]*/
1607       if((isTxPayloadLenAdded != NULLP) && (*isTxPayloadLenAdded == FALSE))
1608       {
1609          DU_LOG("\nDEBUG  -->  SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\
1610                lcNode->lcId);
1611          *isTxPayloadLenAdded = TRUE;
1612          lcNode->allocBO = calculateEstimateTBSize((lcNode->reqBO + TX_PAYLOAD_HDR_LEN),\
1613                mcsIdx, numSymbols, maxPRB, &estPrb);
1614          lcNode->allocBO -=TX_PAYLOAD_HDR_LEN;
1615       }
1616       else if((srRcvd != NULLP) && (*srRcvd == TRUE))
1617       {
1618          DU_LOG("\nDEBUG  --> SCH: LC:%d is the First node to be allocated which includes UL_GRANT_SIZE",\
1619                lcNode->lcId);
1620          *srRcvd = FALSE;
1621          lcNode->reqBO += UL_GRANT_SIZE;
1622          lcNode->allocBO = calculateEstimateTBSize(lcNode->reqBO, mcsIdx, numSymbols, maxPRB, &estPrb);
1623       }
1624       else
1625       {
1626          /*[Step4]*/
1627          lcNode->allocBO = calculateEstimateTBSize(lcNode->reqBO,\
1628                mcsIdx, numSymbols, maxPRB, &estPrb);
1629       }
1630
1631       /*[Step6]:Re-adjust the reservedPRB pool count and *SharedPRB Count based on
1632        * estimated PRB allocated*/
1633       if((isDedicatedPRB == TRUE) && (estPrb <= remReservedPRB))
1634       {
1635          remReservedPRB = remReservedPRB - estPrb;
1636       }
1637       else   /*LC requirement need PRB share from SharedPRB*/
1638       {
1639          if(*sharedPRB <=  (estPrb - remReservedPRB))
1640          {
1641             DU_LOG("\nDEBUG  -->  SCH: SharedPRB is less");
1642             *sharedPRB = 0;
1643          }
1644          else
1645          {
1646             *sharedPRB = *sharedPRB - (estPrb - remReservedPRB);
1647          }
1648          remReservedPRB = 0;
1649       }
1650
1651       /*[Step7]*/
1652       lcNode->reqBO -= lcNode->allocBO;  /*Update the reqBO with remaining bytes unallocated*/
1653       lcNode->allocPRB = estPrb;
1654       cmLListAdd2Tail(lcLL, cmLListDelFrm(lcLL, node));
1655
1656       /*[Step8]:Next loop: First LC to be picked from the list
1657        * because Allocated Nodes are moved to the last*/
1658       node = lcLL->first; 
1659
1660    }
1661    return;
1662 }
1663
1664 /*******************************************************************************************
1665  *
1666  * @brief Check the LC List and fill the LC and GrantSize to be sent to MAC as
1667  * BO Report
1668  *
1669  * @details
1670  *
1671  *    Function : updateGrantSizeForBoRpt
1672  *
1673  *    Functionality:
1674  *             Check the LC List and fill the LC and GrantSize to be sent to MAC as
1675  *             BO Report in dlMsgAlloc Pointer
1676  *
1677  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1678  *             I/P & O/P > dlMsgAlloc[for DL](Pending LC to be added in this context) 
1679  *             I/P & O/P > BsrInfo (applicable for UL)
1680  *             I/P & O/P > accumalatedBOSize
1681  * @return void
1682  *
1683  * *******************************************************************************************/
1684 void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgSchInfo *dlMsgAlloc,\
1685                                 BsrInfo *bsrInfo, uint32_t *accumalatedBOSize)
1686 {
1687    CmLList *node = NULLP, *next = NULLP;
1688    LcInfo *lcNode = NULLP;
1689
1690    if(lcLL == NULLP)
1691    {
1692       DU_LOG("\nERROR --> SCH: LcList not present");
1693       return;
1694    }
1695
1696    if(lcLL->count)
1697    {
1698       node = lcLL->first;
1699    }
1700    else
1701    {
1702       /*lcLL is empty*/
1703       return;
1704    }
1705
1706    /*Traverse List*/
1707    while(node)
1708    {
1709       next = node->next;
1710       lcNode = (LcInfo *)node->node;
1711       if(lcNode != NULLP)
1712       {
1713          DU_LOG("\nINFO   -->  SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
1714                lcNode->lcId, lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB);
1715          if(dlMsgAlloc != NULLP)
1716          {
1717
1718             /*Add this LC to dlMsgAlloc so that if this LC gets allocated, BO
1719              * report for allocation can be sent to MAC*/
1720             dlMsgAlloc->numOfTbs = 1;
1721             dlMsgAlloc->transportBlock[0].lcSchInfo[dlMsgAlloc->transportBlock[0].numLc].lcId = lcNode->lcId;
1722             dlMsgAlloc->transportBlock[0].lcSchInfo[dlMsgAlloc->transportBlock[0].numLc].schBytes = lcNode->allocBO;
1723
1724             /*Calculate the Total Payload/BO size allocated*/
1725             *accumalatedBOSize += dlMsgAlloc->transportBlock[0].lcSchInfo[dlMsgAlloc->transportBlock[0].numLc].schBytes; 
1726
1727             DU_LOG("\nINFO   -->  SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\
1728                   lcNode->lcId,lcNode->reqBO, dlMsgAlloc->transportBlock[0].numLc, *accumalatedBOSize);
1729
1730             dlMsgAlloc->transportBlock[0].numLc++;
1731             handleLcLList(lcLL, lcNode->lcId, DELETE);
1732          }
1733          else if(bsrInfo != NULLP)
1734          {
1735             *accumalatedBOSize += lcNode->allocBO;   
1736             DU_LOG("\nINFO   --> SCH: UL : LCID:%d,reqBO:%d, TotalBO Size:%d",\
1737                   lcNode->lcId,lcNode->reqBO, *accumalatedBOSize);
1738          }
1739       }
1740       node = next;
1741    }/*End of while*/
1742    return;
1743 }
1744
1745 /*******************************************************************
1746 *
1747 * @brief fill DL message information for MSG4 and Dedicated DL Msg
1748 *
1749 * @details
1750 *
1751 *    Function : fillDlMsgInfo
1752 *
1753 *    Functionality:
1754 *       fill DL message information for MSG4 and Dedicated DL Msg
1755 *
1756 * @params[in] DlMsgInfo *dlMsgInfo,  uint16_t crnti
1757 * @params[in] bool isRetx, SchDlHqProcCb *hqP
1758 * @return void
1759 *
1760 *******************************************************************/
1761 void fillDlMsgInfo(DlMsgSchInfo *dlMsgSchInfo, uint16_t crnti, bool isRetx, SchDlHqProcCb *hqP)
1762 {
1763    hqP->tbInfo[0].isEnabled = TRUE;
1764    hqP->tbInfo[0].state = HQ_TB_WAITING;
1765    hqP->tbInfo[0].txCntr++;
1766    hqP->tbInfo[1].isEnabled = TRUE;
1767    hqP->tbInfo[1].state = HQ_TB_WAITING;
1768    hqP->tbInfo[1].txCntr++;
1769    dlMsgSchInfo->crnti = crnti;
1770    dlMsgSchInfo->transportBlock[0].ndi = hqP->tbInfo[0].ndi; /*How to handle two tb case?TBD*/
1771    dlMsgSchInfo->harqProcNum = hqP->procId;
1772    dlMsgSchInfo->dlAssignIdx = 0;
1773    dlMsgSchInfo->pucchTpc = 0;
1774    dlMsgSchInfo->pucchResInd = 0;
1775    dlMsgSchInfo->harqFeedbackInd = hqP->k1;
1776    dlMsgSchInfo->dciFormatId = 1;
1777 }
1778
1779 /*******************************************************************
1780  *
1781  * @brief sch Process pending Msg4 Req
1782  *
1783  * @details
1784  *
1785  *    Function : schProcessMsg4Req
1786  *
1787  *    Functionality:
1788  *       sch Process pending Msg4 Req
1789  *
1790  * @params[in] SchCellCb *cell, cell cb struct pointer
1791  * @params[in] SlotTimingInfo currTime, current timing info
1792  * @params[in] uint8_t ueId, ue ID
1793  * @params[in] bool isRetxMsg4, indicator to MSG4 retransmission
1794  * @params[in] SchDlHqProcCb **msg4HqProc, address of MSG4 HARQ proc pointer
1795  * @return ROK     - success
1796  *         RFAILED - failure
1797  *
1798  *******************************************************************/
1799
1800 uint8_t schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId, bool isRetxMsg4, SchDlHqProcCb **msg4HqProc)
1801 {
1802    uint8_t pdschStartSymbol = 0, pdschNumSymbols = 0;
1803    SlotTimingInfo pdcchTime, pdschTime, pucchTime;
1804    DlMsgSchInfo *dciSlotAlloc = NULLP;    /* Stores info for transmission of PDCCH for Msg4 */
1805    DlMsgSchInfo *msg4SlotAlloc = NULLP;   /* Stores info for transmission of PDSCH for Msg4 */
1806
1807    if(cell == NULL)
1808    {
1809       DU_LOG("\nERROR  -->  SCH: schProcessMsg4Req() : Cell is NULL");
1810       return RFAILED;
1811    }
1812
1813    if (isRetxMsg4 == FALSE)
1814    {
1815       if (RFAILED == schDlGetAvlHqProcess(cell, &cell->ueCb[ueId - 1], msg4HqProc))
1816       {
1817          DU_LOG("\nERROR  -->  SCH: schProcessMsg4Req() : No process");
1818          return RFAILED;
1819       }
1820    }
1821
1822    if(findValidK0K1Value(cell, currTime, ueId, false, &pdschStartSymbol, &pdschNumSymbols, &pdcchTime, &pdschTime,\
1823             &pucchTime, isRetxMsg4, *msg4HqProc, NULLP) != true )
1824    {
1825       DU_LOG("\nERROR  -->  SCH: schProcessMsg4Req() : k0 k1 not found");
1826       return RFAILED;
1827    }
1828
1829    if(cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] == NULL)
1830    {
1831       SCH_ALLOC(dciSlotAlloc, sizeof(DlMsgSchInfo));
1832       if(dciSlotAlloc == NULLP)
1833       {
1834          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciSlotAlloc");
1835          return RFAILED;
1836       }
1837       cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = dciSlotAlloc;
1838       memset(dciSlotAlloc, 0, sizeof(DlMsgSchInfo));
1839    }
1840    else
1841       dciSlotAlloc = cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1];
1842
1843    /* Fill PDCCH and PDSCH scheduling information for Msg4 */
1844    if((schDlRsrcAllocMsg4(cell, pdschTime, ueId, dciSlotAlloc, pdschStartSymbol, pdschNumSymbols, isRetxMsg4, *msg4HqProc)) != ROK)
1845    {
1846       DU_LOG("\nERROR  -->  SCH: Scheduling of Msg4 failed in slot [%d]", pdschTime.slot);
1847       if(!dciSlotAlloc->dlMsgPdschCfg)
1848       {
1849          SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1850          cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
1851       }
1852       return RFAILED;
1853    }
1854
1855    /* Check if both DCI and RAR are sent in the same slot.
1856     * If not, allocate memory RAR PDSCH slot to store RAR info
1857     */
1858    if(pdcchTime.slot == pdschTime.slot)
1859    {
1860       SCH_ALLOC(dciSlotAlloc->dlMsgPdschCfg, sizeof(PdschCfg));
1861       if(!dciSlotAlloc->dlMsgPdschCfg)
1862       {
1863          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciSlotAlloc->dlMsgPdschCfg");
1864          SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
1865          SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1866          cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
1867          return RFAILED;
1868       }
1869       memcpy(dciSlotAlloc->dlMsgPdschCfg, &dciSlotAlloc->dlMsgPdcchCfg->dci[0].pdschCfg, sizeof(PdschCfg));
1870    }
1871    else
1872    {
1873       /* Allocate memory to schedule rarSlot to send RAR, pointer will be checked at schProcessSlotInd() */
1874       if(cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] == NULL)
1875       {
1876          SCH_ALLOC(msg4SlotAlloc, sizeof(DlMsgSchInfo));
1877          if(msg4SlotAlloc == NULLP)
1878          {
1879             DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for msg4SlotAlloc");
1880             SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));
1881             if(!dciSlotAlloc->dlMsgPdschCfg)
1882             {
1883                SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1884                cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
1885             }
1886             return RFAILED;
1887          }
1888          cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] = msg4SlotAlloc;
1889          memset(msg4SlotAlloc, 0, sizeof(DlMsgSchInfo));
1890       }
1891       else
1892          msg4SlotAlloc = cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1];
1893
1894       /* Copy all msg4 pdschcfg info */
1895       msg4SlotAlloc->crnti =dciSlotAlloc->crnti;
1896       msg4SlotAlloc->bwp = dciSlotAlloc->bwp;
1897       SCH_ALLOC(msg4SlotAlloc->dlMsgPdschCfg, sizeof(PdschCfg));
1898       if(msg4SlotAlloc->dlMsgPdschCfg)
1899       {
1900          memcpy(msg4SlotAlloc->dlMsgPdschCfg, &dciSlotAlloc->dlMsgPdcchCfg->dci[0].pdschCfg, sizeof(PdschCfg));
1901       }
1902       else
1903       {
1904          SCH_FREE(dciSlotAlloc->dlMsgPdcchCfg, sizeof(PdcchCfg));    
1905          if(dciSlotAlloc->dlMsgPdschCfg == NULLP)
1906          {
1907             SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1908             cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
1909
1910          }
1911          SCH_FREE(msg4SlotAlloc, sizeof(DlMsgSchInfo));
1912          cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
1913          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for msg4SlotAlloc->dlMsgPdschCfg");
1914          return RFAILED;
1915       }
1916    }
1917
1918    /* PUCCH resource */
1919    schAllocPucchResource(cell, pucchTime, cell->raCb[ueId-1].tcrnti, &cell->ueCb[ueId-1], isRetxMsg4, *msg4HqProc);
1920
1921    cell->schDlSlotInfo[pdcchTime.slot]->pdcchUe = ueId;
1922    cell->schDlSlotInfo[pdschTime.slot]->pdschUe = ueId;
1923    cell->schUlSlotInfo[pucchTime.slot]->pucchUe = ueId;
1924    cell->raCb[ueId-1].msg4recvd = FALSE;
1925    if(isRetxMsg4)
1926    {
1927       cell->ueCb[ueId-1].retxMsg4HqProc= NULLP;
1928    }
1929    return ROK;
1930 }
1931
1932 /*******************************************************************
1933  *
1934  * @brief sch Process pending Sr or Bsr Req
1935  *
1936  * @details
1937  *
1938  *    Function : updateBsrAndLcList
1939  *
1940  *    Functionality:
1941  *       Updating the BSRInfo in UECB and Lclist
1942  *
1943  * @params[in] SchCellCb *cell,  SlotTimingInfo currTime 
1944  * @return ROK     - success
1945  *         RFAILED - failure
1946  *
1947  *******************************************************************/
1948 void updateBsrAndLcList(CmLListCp *lcLL, BsrInfo *bsrInfo, uint8_t status)
1949 {
1950    CmLList *node = NULLP, *next = NULLP;
1951    LcInfo *lcNode = NULLP;
1952
1953    if(lcLL == NULLP)
1954    {
1955       DU_LOG("\nERROR --> SCH: LcList not present");
1956       return;
1957    }
1958
1959    if(lcLL->count)
1960    {
1961       node = lcLL->first;
1962    }
1963    else
1964    {
1965       /*lcLL is empty*/
1966       return;
1967    }
1968
1969    while(node)
1970    {
1971       next = node->next;
1972       lcNode = (LcInfo *)node->node;
1973       if(lcNode != NULLP)
1974       {
1975           /*Only when Status is OK then allocation is marked as ZERO and reqBO
1976            * is updated in UE's DB. If Failure, then allocation is added to reqBO 
1977            * and same is updated in Ue's DB inside BSR Info structure*/
1978          if(status == ROK)
1979          {
1980             lcNode->allocBO = 0;
1981          }
1982
1983          lcNode->reqBO += lcNode->allocBO;
1984          bsrInfo[lcNode->lcId].dataVol = lcNode->reqBO;
1985          if(lcNode->reqBO == 0)
1986          {
1987             handleLcLList(lcLL, lcNode->lcId, DELETE);
1988          }
1989       }
1990       node = next;
1991    }
1992 }
1993
1994 /*******************************************************************
1995  *
1996  * @brief sch Process pending Sr or Bsr Req
1997  *
1998  * @details
1999  *
2000  *    Function : schProcessSrOrBsrReq
2001  *
2002  *    Functionality:
2003  *       sch Process pending Sr or Bsr Req
2004  *
2005  * @params[in] SchCellCb *cell,  SlotTimingInfo currTime
2006  * @params[in] uint8_t ueId, Bool isRetx, SchUlHqProcCb **hqP
2007  * @return true  - success
2008  *         false - failure
2009  *
2010  *******************************************************************/
2011 bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId, bool isRetx, SchUlHqProcCb **hqP)
2012 {
2013    bool k2Found = FALSE;
2014    uint8_t startSymb = 0, symbLen = 0;
2015    uint8_t k2TblIdx = 0, k2Index = 0, k2Val = 0;
2016    SchUeCb *ueCb;
2017    SchK2TimingInfoTbl *k2InfoTbl=NULLP;
2018    SlotTimingInfo dciTime, puschTime;
2019    
2020    if(cell == NULLP)
2021    {
2022       DU_LOG("\nERROR  -->  SCH: schProcessSrOrBsrReq() : Cell is NULL");
2023       return false;
2024    }
2025
2026    ueCb = &cell->ueCb[ueId-1];
2027
2028    if(ueCb == NULLP)
2029    {
2030       DU_LOG("\nERROR  -->  SCH: schProcessSrOrBsrReq() : UE is NULL");
2031       return false;
2032    }
2033
2034    if (isRetx == FALSE)
2035    {
2036       if (schUlGetAvlHqProcess(cell, ueCb, hqP) != ROK)
2037       {
2038          return RFAILED;
2039       }
2040    }
2041
2042    /* Calculating time frame to send DCI for SR */
2043    ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
2044 #ifdef NR_TDD
2045    if(schGetSlotSymbFrmt(dciTime.slot, cell->slotFrmtBitMap) == DL_SLOT)
2046 #endif
2047    {     
2048       if(ueCb->k2TblPrsnt)
2049          k2InfoTbl = &ueCb->k2InfoTbl;
2050       else
2051          k2InfoTbl =  &cell->k2InfoTbl;
2052
2053       for(k2TblIdx = 0; k2TblIdx < k2InfoTbl->k2TimingInfo[dciTime.slot].numK2; k2TblIdx++)
2054       {
2055          k2Index = k2InfoTbl->k2TimingInfo[dciTime.slot].k2Indexes[k2TblIdx];
2056
2057          if(!ueCb->k2TblPrsnt)
2058          {
2059             k2Val = cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2;
2060             startSymb = cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol;
2061             symbLen = cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength;
2062          }
2063          else
2064          {
2065             k2Val = ueCb->ueCfg.spCellCfg.servCellRecfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].k2;
2066             startSymb =  ueCb->ueCfg.spCellCfg.servCellRecfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].startSymbol;
2067             symbLen =  ueCb->ueCfg.spCellCfg.servCellRecfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].symbolLength;
2068          }
2069          /* Check for number of Symbol of PUSCH should be same as original in case of transmisson*/
2070          /* Calculating time frame to send PUSCH for SR */
2071          ADD_DELTA_TO_TIME(dciTime, puschTime, k2Val, cell->numSlots);
2072 #ifdef NR_TDD
2073          if(schGetSlotSymbFrmt(puschTime.slot, cell->slotFrmtBitMap) == DL_SLOT)
2074             continue;
2075 #endif
2076          if(cell->schUlSlotInfo[puschTime.slot]->puschUe != 0)
2077          {
2078             continue;
2079          }
2080          k2Found = true;
2081          if(hqP)
2082          {
2083             ADD_DELTA_TO_TIME(puschTime, (*hqP)->puschTime, 0, cell->numSlots);
2084          }
2085          break;
2086       }
2087    }
2088    
2089    if(k2Found == true)
2090    {
2091       if(cell->api->SchScheduleUlLc(dciTime, puschTime, startSymb, symbLen, isRetx, hqP) != ROK)
2092          return false;
2093    }
2094    else
2095    {
2096       DU_LOG("\nDEBUG  -->  SCH : schProcessSrOrBsrReq(): K2 value is not found");
2097       return false;     
2098    }
2099    return true;
2100 }
2101
2102 /********************************************************************************
2103  *
2104  * @brief Increment the Slot by a input factor
2105  *
2106  * @details
2107  *
2108  *    Function : schIncrSlot
2109  *
2110  *    Functionality:
2111  *       Increment the slot by a input factor till num of Slots configured in a
2112  *       Radio Frame. If it exceeds, move to next sfn.
2113  *
2114  * @params[in/out] SlotTimingInfo timingInfo
2115  *        [in]     uint8_t incr [Increment factor]
2116  *        [in]     numSlotsPerRF [Number of Slots configured per RF as per
2117  *                                numerology]
2118  * @return ROK     - success
2119  *         RFAILED - failure
2120  *
2121  *******************************************************************/
2122 void schIncrSlot(SlotTimingInfo *timingInfo, uint8_t incr, uint16_t numSlotsPerRF)
2123 {
2124    timingInfo->slot += incr;
2125    if(timingInfo->slot >= numSlotsPerRF)
2126    {
2127       timingInfo->sfn += timingInfo->slot/numSlotsPerRF;
2128       timingInfo->slot %= numSlotsPerRF;
2129       if(timingInfo->sfn >  MAX_SFN)
2130       {
2131          timingInfo->sfn %= MAX_SFN;
2132       }
2133    }
2134 }
2135
2136 /*******************************************************************
2137 *
2138 * @brief   Fill PDSCH info in Page Alloc
2139 *
2140 * @details
2141 *
2142 *    Function : schFillPagePdschCfg 
2143 *
2144 *    Functionality: Fill PDSCH info in Page Alloc
2145 *
2146 * @params[in] SchCellCb *cell, PdschCfg *pagePdschCfg, SlotTimingInfo slotTime, 
2147 *             uint16_t tbsSize, uint8_t mcs, uint16_t startPrb
2148 *
2149 * @return pointer to return Value(ROK, RFAILED) 
2150 *
2151 * ****************************************************************/
2152 uint8_t schFillPagePdschCfg(SchCellCb *cell, PageDlSch *pageDlSch, SlotTimingInfo slotTime, uint16_t tbSize, uint8_t mcs, uint16_t startPrb)
2153 {
2154    uint8_t dmrsStartSymbol, startSymbol, numSymbol;
2155
2156    /* fill the PDSCH PDU */
2157
2158    pageDlSch->tbInfo.mcs = mcs;
2159    tbSize = tbSize + TX_PAYLOAD_HDR_LEN;
2160    pageDlSch->tbInfo.tbSize = tbSize;
2161    pageDlSch->dmrs.dmrsType = 0; /* type-1 */
2162    pageDlSch->dmrs.nrOfDmrsSymbols               = NUM_DMRS_SYMBOLS;
2163    pageDlSch->dmrs.dmrsAddPos                    = DMRS_ADDITIONAL_POS;
2164
2165    /* the RB numbering starts from coreset0, and PDSCH is always above SSB */
2166    pageDlSch->freqAlloc.startPrb  = startPrb;
2167    pageDlSch->freqAlloc.numPrb    = schCalcNumPrb(tbSize, mcs, NUM_PDSCH_SYMBOL);
2168    pageDlSch->vrbPrbMapping       = 0; /* non-interleaved */
2169    /* This is Intel's requirement. PDSCH should start after PDSCH DRMS symbol */
2170    pageDlSch->timeAlloc.mappingType         = DMRS_MAP_TYPE_A; /* Type-A */
2171    pageDlSch->timeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */
2172    pageDlSch->timeAlloc.numSymb   = NUM_PDSCH_SYMBOL;
2173
2174    /* Find total symbols occupied including DMRS */
2175    dmrsStartSymbol = findDmrsStartSymbol(4);
2176    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
2177     * in that case only PDSCH symbols are marked as occupied */
2178    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
2179    {
2180       startSymbol = pageDlSch->timeAlloc.startSymb;
2181       numSymbol = pageDlSch->timeAlloc.numSymb;
2182    }
2183    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
2184    else
2185    {
2186       startSymbol = dmrsStartSymbol;
2187       numSymbol = pageDlSch->dmrs.nrOfDmrsSymbols + pageDlSch->timeAlloc.numSymb;
2188    }
2189
2190    /* Allocate the number of PRBs required for DL PDSCH */
2191    if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
2192                &pageDlSch->freqAlloc.startPrb, pageDlSch->freqAlloc.numPrb)) != ROK)
2193    {
2194       DU_LOG("\nERROR  --> SCH : allocatePrbDl() failed for DL MSG");
2195       return RFAILED;
2196    }
2197    return ROK;
2198 }
2199
2200 /**
2201  * @brief Handles retransmission for MSG3
2202  *
2203  * @details
2204  *
2205  *     Function : schMsg3RetxSchedulingForUe
2206  *      
2207  *      This function handles retransmission for MSG3
2208  *           
2209  *  @param[in]  SchRaCb *raCb, RA cb pointer
2210  *  @return  
2211  *      -# ROK
2212  *      -# RFAILED
2213  **/
2214 uint8_t schMsg3RetxSchedulingForUe(SchRaCb *raCb)
2215 {
2216    bool      k2Found = false;
2217    uint16_t             dciSlot = 0;
2218    SlotTimingInfo       dciTime, msg3Time;
2219    SchCellCb            *cell = NULLP;
2220    SlotTimingInfo       currTime;
2221    DciInfo  *dciInfo = NULLP;
2222    cell = raCb->cell;
2223    currTime = cell->slotInfo;
2224
2225    /* Calculating time frame to send DCI for MSG3 Retx*/
2226    ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
2227 #ifdef NR_TDD
2228    /* Consider this slot for sending DCI, only if it is a DL slot */
2229    if(schGetSlotSymbFrmt(dciSlot, raCb->cell->slotFrmtBitMap) == DL_SLOT)
2230 #endif
2231    {
2232       /* If PDCCH is already scheduled on this slot, cannot schedule PDSCH for another UE here. */
2233       if(cell->schDlSlotInfo[dciSlot]->pdcchUe != 0)
2234          return false;
2235
2236       k2Found = schGetMsg3K2(cell, &raCb->msg3HqProc, dciTime.slot, &msg3Time, TRUE);
2237
2238       if (!k2Found)
2239       {
2240          return RFAILED;
2241       }
2242       SCH_ALLOC(dciInfo, sizeof(DciInfo));
2243       if(!dciInfo)
2244       {
2245          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciInfo alloc");
2246          return RFAILED;
2247       }
2248       cell->schDlSlotInfo[msg3Time.slot]->ulGrant = dciInfo;
2249       SCH_ALLOC(cell->schUlSlotInfo[msg3Time.slot]->schPuschInfo, sizeof(SchPuschInfo));
2250       memset(dciInfo,0,sizeof(DciInfo));
2251       schFillUlDciForMsg3Retx(raCb, cell->schUlSlotInfo[msg3Time.slot]->schPuschInfo, dciInfo);
2252    }   
2253    raCb->retxMsg3HqProc = NULLP;
2254    return ROK;
2255 }
2256
2257 /**
2258  * @brief Get K2 value for MSG3
2259  *
2260  * @details
2261  *
2262  *     Function : schGetMsg3K2
2263  *      
2264  *      This function gets K2 for MSG3
2265  *           
2266  *  @param[in]  SchCellCb *cell, Cell cb struc pointer
2267  *  @param[in]  SchUlHqProcCb* msg3HqProc, msg3 harq proc pointer
2268  *  @param[in]  uint16_t dlTime, DL time of scheduling
2269  *  @param[in]  SlotTimingInfo *msg3Time, MSG3 timing info
2270  *  @param[in]  bool isRetx, indicates MSG3 retransmission
2271  *  @return  
2272  *      -# true
2273  *      -# false
2274  **/
2275 bool schGetMsg3K2(SchCellCb *cell, SchUlHqProcCb* msg3HqProc, uint16_t dlTime, SlotTimingInfo *msg3Time, bool isRetx)
2276 {
2277    bool      k2Found = false;
2278    uint8_t   k2TblIdx = 0;
2279    uint8_t   k2Index = 0;
2280    uint8_t   k2 = 0;
2281    uint8_t   numK2 = 0;
2282    uint8_t   puschMu = 0;
2283    uint8_t   msg3Delta = 0, msg3MinSchTime = 0;
2284 #ifdef NR_TDD
2285    uint8_t   totalCfgSlot = 0;
2286 #endif
2287    SchK2TimingInfoTbl   *msg3K2InfoTbl=NULLP;
2288    SlotTimingInfo       currTime, msg3TempTime;
2289    currTime = cell->slotInfo;
2290    puschMu = cell->numerology;
2291
2292    if (isRetx)
2293    {
2294       if(!msg3HqProc)
2295          return false;
2296
2297       numK2 = cell->k2InfoTbl.k2TimingInfo[dlTime].numK2;
2298       msg3K2InfoTbl = &cell->msg3K2InfoTbl;
2299       msg3MinSchTime = 0;
2300       msg3Delta = 0;
2301    }
2302    else
2303    {
2304       numK2 = cell->msg3K2InfoTbl.k2TimingInfo[dlTime].numK2;
2305       msg3K2InfoTbl = &cell->k2InfoTbl;
2306       msg3MinSchTime = minMsg3SchTime[cell->numerology];
2307       msg3Delta = puschDeltaTable[puschMu];
2308    }
2309
2310    for(k2TblIdx = 0; k2TblIdx < numK2; k2TblIdx++)
2311    {
2312       k2Index = msg3K2InfoTbl->k2TimingInfo[dlTime].k2Indexes[k2TblIdx];
2313
2314       k2 = cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2;
2315       if (isRetx)
2316       {
2317          if ((msg3HqProc->strtSymbl != cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol) ||
2318             (msg3HqProc->numSymbl != cell->cellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength))
2319          {
2320             continue;
2321          }
2322       }
2323       /* Delta is added to the slot allocation for msg3 based on 38.214 section 6.1.2.1 */
2324       k2 = k2 + msg3Delta;
2325       if(k2 >= msg3MinSchTime)
2326       {
2327          ADD_DELTA_TO_TIME(currTime, msg3TempTime, k2, cell->numSlots);
2328 #ifdef NR_TDD
2329          if(schGetSlotSymbFrmt(msg3TempTime.slot % totalCfgSlot, cell->slotFrmtBitMap) == DL_SLOT)
2330             continue;
2331 #endif
2332          /* If PUSCH is already scheduled on this slot, another PUSCH
2333           * pdu cannot be scheduled here */
2334          if(cell->schUlSlotInfo[msg3TempTime.slot]->puschUe != 0)
2335             continue;
2336          k2Found = true;
2337          break;
2338       }
2339    }
2340    if (k2Found == true)
2341    {
2342       msg3Time->slot = msg3TempTime.slot;
2343       msg3Time->sfn = msg3TempTime.sfn;
2344       msg3Time->slot = msg3TempTime.slot;
2345    }
2346    return k2Found;
2347 }
2348
2349 /*
2350  *  * @brief : This Function fills the Coreset and SS info based on PDCCH Cfg received for a UE
2351  *
2352  *     Function : fillUeCoresetAndSsInfo
2353  *
2354  * For a Coreset, capture the following details which will be used during pdcch allocation
2355  *   [Step 1]: Count number of RBG and calculate TotalPRBs which can be used 
2356  *   [Step 2]: Get the reference pointer for Coreset and Its SearchSpace.
2357  *   [Step 3]: A CCE will have 6 RBs in TOTAL. If duration increases, CCE will
2358  *             occupy less number of PRBs(1RB x 1 OFDM Symbol). Eg. If duration = 2, then
2359  *             instead of 6 PRBs, CCE will only occupy 3 PRBs and 2 OFDM symbols.
2360  *   [Step 4]: Based on CoresetSize, fill AggLvl-CQI mapping by calculating the dciSize.
2361  *   [Step 5]: Calculate Y value for this coreset and UE
2362  *
2363  *   @Params[in]: UeCb,
2364  *  [return]: ROK, RFAILED : Memory allocation failure.
2365  **/
2366 uint8_t fillUeCoresetAndSsInfo(SchUeCb *ue)
2367 {
2368    uint8_t  cRSetIdx = 0,ssIdx = 0; 
2369    uint16_t rbgCount = 0;
2370    SchPdcchConfig *pdcchCfg = NULLP;
2371
2372    pdcchCfg =  &ue->ueCfg.spCellCfg.servCellRecfg.initDlBwp.pdcchCfg;
2373    if(pdcchCfg == NULLP)
2374    {
2375      DU_LOG("\nERROR  --> SCH: PDCCH Cfg is not received thus skip filling of Coreset & SS info");
2376      return RFAILED;
2377    }
2378    for(cRSetIdx = 0; cRSetIdx < pdcchCfg->numCRsetToAddMod; cRSetIdx++ )
2379    {
2380       /*[Step 1]: *//*Size of coreset: Number of PRBs in a coreset*/
2381       rbgCount = countRBGFrmCoresetFreqRsrc(pdcchCfg->cRSetToAddModList[cRSetIdx].freqDomainRsrc);
2382       if(rbgCount)
2383       {
2384          ue->pdcchInfo[cRSetIdx].totalPrbs = ((rbgCount) * NUM_PRBS_PER_RBG);
2385       }
2386       else
2387       {
2388          DU_LOG("\nERROR  -->  SCH : CORESETSize is zero in fillCoresetAndSsConfg");
2389          continue;
2390       }
2391       /*[Step 2]:*/
2392       ue->pdcchInfo[cRSetIdx].cRSetRef = &pdcchCfg->cRSetToAddModList[cRSetIdx];
2393       for(ssIdx = 0; ssIdx < pdcchCfg->numSearchSpcToAddMod; ssIdx++)
2394       {
2395          if(pdcchCfg->searchSpcToAddModList[ssIdx].cRSetId == pdcchCfg->cRSetToAddModList[cRSetIdx].cRSetId)
2396          {
2397             ue->pdcchInfo[cRSetIdx].ssRef = &pdcchCfg->searchSpcToAddModList[ssIdx];
2398             break;
2399          }
2400       }
2401
2402       /*[Step 3]:*/
2403       /*nrOfPRBPerCce is Number of PRBs occupied by a CCE based on Duration*/
2404       ue->pdcchInfo[cRSetIdx].nrOfPRBPerCce = NUM_PRBS_PER_RBG/pdcchCfg->cRSetToAddModList[cRSetIdx].duration;
2405       ue->pdcchInfo[cRSetIdx].totalCceCount = rbgCount * pdcchCfg->cRSetToAddModList[cRSetIdx].duration;
2406
2407       /*[Step 4]:*/
2408       fillCqiAggLvlMapping(&ue->pdcchInfo[cRSetIdx]);
2409
2410       /*[Step 5]:*/
2411       if(RFAILED == schUpdValY(ue, &ue->pdcchInfo[cRSetIdx]))
2412       {
2413          return RFAILED;
2414       }
2415    }
2416    return ROK;
2417 }
2418
2419 /*
2420  *  @brief: Function will validate a slot for PDCCH allocation
2421  *
2422  *  Function: schPdcchSlotValidation
2423  *
2424  *  As per 3gpp Spec 38.331, SearchSpace parameter, Every SearchSpace will have
2425  *  details of which slot and after how many slot the UE will monitor for PDCCH.
2426  *  Thus, while PDCCH allocation we need to ensure the above validation passes.
2427  *
2428  *  @param [IN]: PDCCH time, SearchSpace Info, numSlots in Cell
2429  *         [RETURN]: Flag depicting the slot validation
2430  * */
2431 bool schPdcchSlotValidation(SlotTimingInfo pdcchTime, SchSearchSpace *searchSpace, uint16_t numSlots)
2432 {
2433     bool     isSlotValid = false;
2434     uint16_t slotNum = 0, mSlotPeriodicityVal = 0;
2435
2436     /*Converting the timing info in units of Slots*/
2437     slotNum = (pdcchTime.sfn * numSlots)+pdcchTime.slot;
2438
2439     mSlotPeriodicityVal = \
2440     schConvertSlotPeriodicityEnumToValue(searchSpace->mSlotPeriodicityAndOffset.mSlotPeriodicity);
2441
2442     if(!mSlotPeriodicityVal)
2443     {
2444        DU_LOG("\nERROR   --> SCH: Slot Periodicity is ZERO thus cant proceed with this SearchSpace");
2445        return false;
2446     }
2447     /*The Monitoring slot begins from offset thus skip the slots which are less
2448      * than offset value*/
2449     if((slotNum >= searchSpace->mSlotPeriodicityAndOffset.mSlotOffset))
2450     {
2451         /*A pdcch Slot will start after Slotoffset and will get repeated after every
2452          * SlotPeriodicity*/
2453         if(((slotNum - searchSpace->mSlotPeriodicityAndOffset.mSlotOffset) % mSlotPeriodicityVal) == 0) 
2454         {
2455            DU_LOG("\nINFO   --> SCH: SFN:%d/Slot:%d, is a Valid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
2456            isSlotValid = true;
2457         }
2458         else
2459         {
2460            DU_LOG("\nINFO   --> SCH: SFN:%d/Slot:%d, is InValid PDCCH slot",pdcchTime.sfn, pdcchTime.slot);
2461         }
2462     }
2463     return (isSlotValid); 
2464 }
2465
2466 /*
2467  *  @brief: Function to check if PDCCH is available for a cceIndex
2468  *
2469  *  Function: schCheckPdcchAvail
2470  *
2471  *   This function checks if the PRBs available for a particular CCE during
2472  *   PDCCH allocation
2473  *   [Step 1]: Calculate the rbgIndex from cceIndex which depends on Coreset symbol duration
2474  *   i.e. a) If symbolDuration = 1; numPrbs in RBG (6) = numPrbPerCCE thus one on
2475  *        one mapping between rbgIndex and cceIndex
2476  *        b) if SymbolDuration =2; NumPrbs in RBG(6) = numPrbPerCCE * duration
2477  *        as CCE needs 6 REG thus in 3 PRBs whole CCE can contain 
2478  *        c) and so on
2479  *
2480  *   [Step 2]: Again StartPRB for a rbgIndex may not be same for CCE Index which
2481  *             depends on duration. If duration=2, then two CCE can be occupied
2482  *             in one RBGIndex thus StarPrb for secondCCE will be
2483  *             numPrbsPerCCE(3) away.
2484  *
2485  *   @params[in]: CellCb, SlotTime, cceIndex, PDcchInfo, aggLvl
2486  * */
2487 bool schCheckPdcchAvail(SchCellCb *cellCb, SlotTimingInfo slotTime, uint8_t cceIndex,\
2488                     SchPdcchInfo *pdcchInfo, uint8_t aggLvl )
2489 {
2490     uint8_t rbgIndex = 0, ret = 0, startSymbol = 0;
2491     uint16_t startPrb = MAX_NUM_RB, numPrb = 0;
2492
2493     /*[Step 1]: rbgIndex to locate in FreqDomainResource parmaeter in
2494      * SearchSpace*/
2495     rbgIndex = cceIndex / (pdcchInfo->cRSetRef->duration);
2496    
2497     /*Extract StartPRB for that RBGIndex*/
2498     startPrb = extractStartPrbForRBG(pdcchInfo->cRSetRef->freqDomainRsrc, rbgIndex);
2499     if(startPrb == MAX_NUM_RB)
2500     {
2501        DU_LOG("\nERROR  -->  SCH: No RBG is allocated for PDCCH in this Coreset");
2502        return false;
2503     }
2504     /*[Step 2]: Adjust StartPrb based on CCEIndex and duration*/
2505     startPrb = startPrb + ((cceIndex % pdcchInfo->cRSetRef->duration) * (pdcchInfo->nrOfPRBPerCce));
2506     startSymbol = findSsStartSymbol(pdcchInfo->ssRef->mSymbolsWithinSlot);
2507
2508     /*numPrb will also get adjusted with duration*/
2509     numPrb = (NUM_PRBS_PER_RBG * aggLvl) / pdcchInfo->cRSetRef->duration;
2510     DU_LOG("\nDEBUG  -->  SCH: RBG found for cceIndex:%d, AggLvl:%d and SymbolDuration%d with StartPrb:%d, numPrb:%d",\
2511             cceIndex, aggLvl, pdcchInfo->cRSetRef->duration, startPrb, numPrb);
2512
2513     ret = allocatePrbDl(cellCb, slotTime, startSymbol,\
2514                          pdcchInfo->cRSetRef->duration, &startPrb, numPrb);
2515     
2516     if(ret == RFAILED)
2517     {
2518        DU_LOG("\nERROR -->  SCH: PRBs can't be allocated as they are unavailable");
2519        return false;
2520     }
2521     return true;
2522
2523 }
2524
2525 /*
2526  * @brief: Function to select particular UE based on validation of PDCCH allocation
2527  *
2528  *    Function: 
2529  *    This function will have multiple layers of validation for PDCCH allocation 
2530  *    based on CORESET and SearchSpace configuration and availability.
2531  *
2532  *    [Step 1]: Check if the slot is pdcch Slot or not based on SearchSpace's
2533  *    monitoringSlotInfo.
2534  *    [Step 2]: Check the CQI for this UE and decide upon which Agg Level has to
2535  *    be used for this PDCCH transmission
2536  *    [Step 3]: find the AggLevel for this CQI = base aggregation level
2537  *    [Step 4]: NextLowerAggLvl will be the next lower aggLevel when PDCCH
2538  *    allocation fails for base agg Level.
2539  *    [Step 5]: For each candidate , calculate the CCE Index as per TS
2540  *    38.213v15, Sec 10.1 and also check PRBs falling in that CCEIndex is free.
2541  *    [Step 6]: If Step 5 fails, move to next candidate and if Candidate gets
2542  *    exhausted then fallback to nextAggLevel. Because as we decrease aggLevel,
2543  *    numberOfCCEReq decreases so chances of PDCCH allocation increases even
2544  *    though lowerAggLevel will not guarantee transmission of PDCCH as per CQI
2545  *    reported.(CQI less, AggiLvlRequried is More)
2546  *
2547  *    @params[IN]: SchUeCb and PdcchTime
2548  *          [RETURN]: isPDCCHAllocted flag(true = UE can be selected as a
2549  *          candidate )
2550  * */
2551 bool schDlCandidateSelection(SchUeCb *ueCb, SlotTimingInfo pdcchTime, SchPdcchAllocInfo *pdcchAllocInfo)
2552 {
2553     uint8_t cRSetIdx = 0, cceIndex = 0;
2554     uint8_t cqi = 0, candIdx = 0;
2555     uint8_t baseAggLvl = 0, nextLowerAggLvl = 0, numCandidates = 0;
2556     SchPdcchInfo *pdcchInfo = NULLP;
2557     uint32_t a = 0, b = 0;
2558
2559     for(cRSetIdx = 0; cRSetIdx < MAX_NUM_CRSET; cRSetIdx++)
2560     {
2561        pdcchInfo = &ueCb->pdcchInfo[cRSetIdx];
2562        if(pdcchInfo->cRSetRef == NULLP)
2563        {
2564           DU_LOG("\nINFO   -->  SCH: Coreset is not availabe at Index:%d",cRSetIdx);
2565           continue;
2566        }
2567        /*[Step 1]:*/
2568        if(false == schPdcchSlotValidation(pdcchTime, pdcchInfo->ssRef, ueCb->cellCb->numSlots))
2569        {
2570           DU_LOG("\nINFO   -->  SCH: This slot is not valid for PDCCH in this CORESET:%d.",pdcchInfo->cRSetRef->cRSetId);
2571           break;
2572        }
2573        /*[Step 2]:*/
2574        /*TODO: CQI is reported in DL_CQI_IND which has to be processed and
2575         * report has to be stored in ueCb.For now, HardCoding the value*/
2576         cqi = 5;
2577
2578         /*[Step 3]: */
2579         baseAggLvl = pdcchInfo->cqiIndxAggLvlMap[cqi];
2580
2581         /*[Step 4]:*/
2582         nextLowerAggLvl = baseAggLvl;
2583
2584         /*Loop to traverse through each AggLvl from higher value of aggLevel to
2585          * 1 AggLvl*/
2586         do
2587         {
2588            /*Configured num of candidates for each Agg Level in search space */
2589            numCandidates = extractNumOfCandForAggLvl(pdcchInfo->ssRef, nextLowerAggLvl); 
2590            if(!numCandidates)
2591            {
2592              DU_LOG("\nINFO   --> SCH:  Num Of Candidates configured for this AggLvel:%d is ZERO",baseAggLvl);
2593            }
2594
2595            /*[Step 5]:*/
2596            for(candIdx= 0; candIdx < numCandidates; candIdx++)
2597            {
2598                /*Formula reference 3GPP TS 38.213v15, Sec 10.1, Variable 'a' and
2599                 * 'b' is used for segmenting the formulat for readability purpose
2600                 * */
2601                a = pdcchInfo->y[pdcchTime.slot] + \
2602                      ceil((candIdx * pdcchInfo->totalCceCount)/(baseAggLvl * numCandidates));
2603                b = ceil(pdcchInfo->totalCceCount * baseAggLvl);
2604                cceIndex = baseAggLvl * (a % b); 
2605                if(schCheckPdcchAvail(ueCb->cellCb, pdcchTime, cceIndex, pdcchInfo,nextLowerAggLvl) == true)
2606                {
2607                   DU_LOG("\nINFO   -->  SCH: PDCCH allocation is successful at cceIndex:%d",cceIndex);
2608                   pdcchAllocInfo->cRSetId = pdcchInfo->cRSetRef->cRSetId;
2609                   pdcchAllocInfo->aggLvl = nextLowerAggLvl;
2610                   pdcchAllocInfo->cceIndex = cceIndex;
2611                   pdcchAllocInfo->ssId = pdcchInfo->ssRef->searchSpaceId;
2612                   return true;  
2613                }
2614            }
2615            nextLowerAggLvl = nextLowerAggLvl >> 1;
2616         }while(nextLowerAggLvl > 0 && nextLowerAggLvl <= 16);
2617     }
2618     return false;
2619 }
2620 /**********************************************************************
2621   End of file
2622  **********************************************************************/
2623