fc845eb1d43129c5b4ba9d4a0868ae94beae3b4e
[o-du/l2.git] / src / 5gnrsch / sch.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:     sch.c
22   
23      Type:     C source file
24   
25      Desc:     C source code for scheduler fucntions
26   
27      File:     sch.c
28   
29 **********************************************************************/
30
31 /** @file sch.c
32 @brief This file implements the schedulers main access to MAC layer code.
33 */
34 #include "common_def.h" 
35 #include "du_app_mac_inf.h"
36 #include "lrg.h"
37 #include "tfu.h"
38 #include "du_log.h"
39 #include "rgr.h"
40 #include "rg_sch_inf.h"
41 #include "rg_sch.h"
42
43 #include "tfu.x"           /* TFU types */
44 #include "lrg.x"           /* layer management typedefs for MAC */
45 #include "rgr.x"           /* layer management typedefs for MAC */
46 #include "rg_sch_inf.x"         /* typedefs for Scheduler */
47 #include "mac_sch_interface.h"
48 #include "sch.h"
49 #include "sch_utils.h"
50
51 void SchFillCfmPst(Pst *reqPst,Pst *cfmPst,RgMngmt *cfm);
52
53 /* local defines */
54 SchCellCfgCfmFunc SchCellCfgCfmOpts[] = 
55 {
56    packSchCellCfgCfm,     /* LC */
57    MacProcSchCellCfgCfm,  /* TC */
58    packSchCellCfgCfm      /* LWLC */
59 };
60
61 SchSliceCfgRspFunc SchSliceCfgRspOpts[] =
62 {
63    packSchSliceCfgRsp,     /* LC */
64    MacProcSchSliceCfgRsp,  /* TC */
65    packSchSliceCfgRsp      /* LWLC */
66
67 };
68
69 SchSliceReCfgRspFunc SchSliceReCfgRspOpts[] =
70 {
71    packSchSliceReCfgRsp,     /* LC */
72    MacProcSchSliceReCfgRsp,  /* TC */
73    packSchSliceReCfgRsp      /* LWLC */
74 };
75 /**
76  * @brief Task Initiation function. 
77  *
78  * @details
79  *
80  *     Function : schActvInit
81  *     
82  *     This function is supplied as one of parameters during MAC's 
83  *     task registration. MAC will invoke this function once, after
84  *     it creates and attaches this TAPA Task to a system task.
85  *     
86  *  @param[in]  Ent Entity, the entity ID of this task.     
87  *  @param[in]  Inst Inst, the instance ID of this task.
88  *  @param[in]  Region Region, the region ID registered for memory 
89  *              usage of this task.
90  *  @param[in]  Reason Reason.
91  *  @return  int
92  *      -# ROK
93  **/
94 uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason)
95 {
96    Inst inst = (instId  - SCH_INST_START);
97
98    /* Initialize the MAC TskInit structure to zero */
99    memset ((uint8_t *)&schCb[inst], 0, sizeof(schCb));
100
101    /* Initialize the MAC TskInit with received values */
102    schCb[inst].schInit.ent = entity;
103    schCb[inst].schInit.inst = inst;
104    schCb[inst].schInit.region = region;
105    schCb[inst].schInit.pool = 0;
106    schCb[inst].schInit.reason = reason;
107    schCb[inst].schInit.cfgDone = FALSE;
108    schCb[inst].schInit.acnt = FALSE;
109    schCb[inst].schInit.usta = FALSE;
110    schCb[inst].schInit.trc = FALSE;
111    schCb[inst].schInit.procId = ODU_GET_PROCID();
112
113    return ROK;
114 } /* schActvInit */
115
116 /**
117  * @brief Scheduler instance Configuration Handler. 
118  *
119  * @details
120  *
121  *     Function : SchInstCfg
122  *     
123  *     This function in called by SchProcGenCfgReq(). It handles the
124  *     general configurations of the scheduler instance. Returns
125  *     reason for success/failure of this function.
126  *     
127  *  @param[in]  RgCfg *cfg, the Configuaration information 
128  *  @return  uint16_t
129  *      -# LCM_REASON_NOT_APPL 
130  *      -# LCM_REASON_INVALID_MSGTYPE
131  *      -# LCM_REASON_MEM_NOAVAIL
132  **/
133 uint8_t SchInstCfg(RgCfg *cfg, Inst  dInst)
134 {
135    uint16_t ret = LCM_REASON_NOT_APPL;
136    Inst     inst = (dInst - SCH_INST_START);
137
138    DU_LOG("\nDEBUG  -->  SCH : Entered SchInstCfg()");
139    /* Check if Instance Configuration is done already */
140    if (schCb[inst].schInit.cfgDone == TRUE)
141    {
142       return LCM_REASON_INVALID_MSGTYPE;
143    }
144    /* Update the Pst structure for LM interface */
145    memcpy(&schCb[inst].schInit.lmPst,
146          &cfg->s.schInstCfg.genCfg.lmPst,
147          sizeof(Pst));
148
149    schCb[inst].schInit.inst = inst;
150    schCb[inst].schInit.lmPst.srcProcId = schCb[inst].schInit.procId;
151    schCb[inst].schInit.lmPst.srcEnt = schCb[inst].schInit.ent;
152    schCb[inst].schInit.lmPst.srcInst = schCb[inst].schInit.inst +
153       SCH_INST_START;
154    schCb[inst].schInit.lmPst.event = EVTNONE;
155
156    schCb[inst].schInit.region = cfg->s.schInstCfg.genCfg.mem.region;
157    schCb[inst].schInit.pool = cfg->s.schInstCfg.genCfg.mem.pool;
158    schCb[inst].genCfg.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes;
159 #ifdef LTE_ADV
160    schCb[inst].genCfg.forceCntrlSrbBoOnPCel =  cfg->s.schInstCfg.genCfg.forceCntrlSrbBoOnPCel;
161    schCb[inst].genCfg.isSCellActDeactAlgoEnable =  cfg->s.schInstCfg.genCfg.isSCellActDeactAlgoEnable;
162 #endif
163    schCb[inst].genCfg.startCellId    = cfg->s.schInstCfg.genCfg.startCellId;
164
165    /* Initialzie the timer queue */   
166    memset(&schCb[inst].tmrTq, 0, sizeof(CmTqType) * SCH_TQ_SIZE);
167    /* Initialize the timer control point */
168    memset(&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
169    schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
170
171    /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
172    /* Timer Registration request to system services */
173    if (ODU_REG_TMR_MT(schCb[inst].schInit.ent, dInst,
174             (int)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
175    {
176       DU_LOG("\nERROR  -->  SCH : SchInstCfg(): Failed to "
177             "register timer.");
178       return (LCM_REASON_MEM_NOAVAIL);
179    }   
180               
181    /* Set Config done in TskInit */
182    schCb[inst].schInit.cfgDone = TRUE;
183    DU_LOG("\nINFO   -->  SCH : Scheduler gen config done");
184
185    return ret;
186 }
187
188 /**
189  * @brief Layer Manager Configuration request handler. 
190  *
191  * @details
192  *
193  *     Function : SchProcGenCfgReq
194  *     
195  *     This function handles the configuration
196  *     request received at scheduler instance from the Layer Manager.
197  *     -# Based on the cfg->hdr.elmId.elmnt value it invokes one of the
198  *        functions rgHdlGenCfg() or rgHdlSapCfg().
199  *     -# Invokes RgMiLrgSchCfgCfm() to send back the confirmation to the LM.
200  *     
201  *  @param[in]  Pst *pst, the post structure     
202  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
203  *  @return  S16
204  *      -# ROK
205  **/
206 uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg)
207 {
208    uint8_t   ret = LCM_PRIM_OK;
209    uint16_t  reason = LCM_REASON_NOT_APPL;
210    RgMngmt   cfm;
211    Pst       cfmPst;
212
213 #ifdef CALL_FLOW_DEBUG_LOG
214    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : GENERAL_CFG_REQ\n");
215 #endif
216
217    if(pst->dstInst < SCH_INST_START)
218    {
219       DU_LOG("\nERROR  -->  SCH : Invalid inst ID");
220       DU_LOG("\nERROR  -->  SCH : SchProcGenCfgReq(): "
221             "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); 
222       return ROK;
223    }
224    DU_LOG("\nINFO   -->  SCH : Received scheduler gen config");
225    /* Fill the post structure for sending the confirmation */
226    memset(&cfmPst, 0 , sizeof(Pst));
227    SchFillCfmPst(pst, &cfmPst, cfg);
228
229    memset(&cfm, 0, sizeof(RgMngmt));
230
231 #ifdef LMINT3
232    cfm.hdr.transId =
233       cfg->hdr.transId;
234 #endif
235
236    cfm.hdr.elmId.elmnt = cfg->hdr.elmId.elmnt;
237    switch(cfg->hdr.elmId.elmnt)
238    {
239       case STSCHINST:
240          reason = SchInstCfg(&cfg->t.cfg,pst->dstInst );
241          break;
242       default:
243          ret = LCM_PRIM_NOK;
244          reason = LCM_REASON_INVALID_ELMNT;
245          DU_LOG("\nERROR  -->  SCH : Invalid Elmnt=%d", cfg->hdr.elmId.elmnt);
246          break;
247    }
248
249    if (reason != LCM_REASON_NOT_APPL)
250    {
251       ret = LCM_PRIM_NOK;
252    }
253
254    cfm.cfm.status = ret;
255    cfm.cfm.reason = reason;
256
257    SchSendCfgCfm(&cfmPst, &cfm);
258    /*   SCH_FREE(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */
259
260    return ROK;
261 }/*-- SchProcGenCfgReq --*/
262
263 /**
264  * @brief slot indication from MAC to SCH.
265  *
266  * @details
267  *
268  *     Function : MacSchSlotInd 
269  *      
270  *      This API is invoked by PHY to indicate slot indication to Scheduler for
271  *      a cell.
272  *           
273  *  @param[in]  Pst            *pst
274  *  @param[in]  SlotTimingInfo    *slotInd
275  *  @return  S16
276  *      -# ROK 
277  *      -# RFAILED 
278  **/
279 uint8_t MacSchSlotInd(Pst *pst, SlotTimingInfo *slotInd)
280 {
281    Inst  inst = pst->dstInst-SCH_INST_START;
282
283 #ifdef CALL_FLOW_DEBUG_LOG
284    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SLOT_IND_TO_SCH\n");
285 #endif
286
287    schProcessSlotInd(slotInd, inst);
288
289    return ROK;
290 }  /* MacSchSlotInd */
291
292 /*******************************************************************
293  *
294  * @brief Processes Rach indication from MAC 
295  *
296  * @details
297  *
298  *    Function : MacSchRachInd
299  *
300  *    Functionality:
301  *      Processes Rach indication from MAC
302  *
303  * @params[in] 
304  * @return ROK     - success
305  *         RFAILED - failure
306  *
307  * ****************************************************************/
308 uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd)
309 {
310    Inst  inst = pst->dstInst-SCH_INST_START;
311
312 #ifdef CALL_FLOW_DEBUG_LOG
313    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_RACH_IND_TO_SCH\n");
314 #endif
315
316    DU_LOG("\nINFO  -->  SCH : Received Rach indication");
317    schProcessRachInd(rachInd, inst);
318    return ROK;
319 }
320
321 /*******************************************************************
322  *
323  * @brief Processes CRC indication from MAC 
324  *
325  * @details
326  *
327  *    Function : MacSchCrcInd
328  *
329  *    Functionality:
330  *      Processes CRC indication from MAC
331  *
332  * @params[in] Post structure
333  *             Crc Indication
334  * @return ROK     - success
335  *         RFAILED - failure
336  *
337  * ****************************************************************/
338 uint8_t MacSchCrcInd(Pst *pst, CrcIndInfo *crcInd)
339 {
340 #ifdef CALL_FLOW_DEBUG_LOG
341    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n");
342 #endif
343
344    switch(crcInd->crcInd[0])
345    {
346       case CRC_FAILED:
347          DU_LOG("\nDEBUG  -->  SCH : Received CRC indication. CRC Status [FAILURE]");
348          break;
349       case CRC_PASSED:
350          DU_LOG("\nDEBUG  -->  SCH : Received CRC indication. CRC Status [PASS]");
351          break;
352       default:
353          DU_LOG("\nDEBUG  -->  SCH : Invalid CRC state %d", crcInd->crcInd[0]);
354          return RFAILED;
355    }
356    return ROK;
357 }
358
359 #ifdef NR_TDD
360 /**
361  *@brief Returns TDD periodicity in micro seconds
362  *
363  * @details
364  * 
365  * Function : schGetPeriodicityInMsec 
366  * 
367  * This API retunrs TDD periodicity in micro seconds
368  * 
369  * @param[in] DlUlTxPeriodicity 
370  * @return  periodicityInMsec
371  * **/
372
373 uint16_t schGetPeriodicityInMsec(DlUlTxPeriodicity tddPeriod)
374 {
375    uint16_t  periodicityInMsec = 0;
376    switch(tddPeriod)
377    {
378       case TX_PRDCTY_MS_0P5:
379       {
380          periodicityInMsec = 500;
381          break;
382       }
383       case TX_PRDCTY_MS_0P625:
384       {
385          periodicityInMsec = 625;
386          break;
387       }
388       case TX_PRDCTY_MS_1:
389       {
390          periodicityInMsec = 1000;
391          break;
392       }
393       case TX_PRDCTY_MS_1P25:
394       {
395          periodicityInMsec = 1250;
396          break;
397       }
398       case TX_PRDCTY_MS_2:
399       {
400          periodicityInMsec = 2000;
401          break;
402       }
403       case TX_PRDCTY_MS_2P5:
404       {
405          periodicityInMsec = 2500;
406          break;
407       }
408       case TX_PRDCTY_MS_5:
409       {
410          periodicityInMsec = 5000;
411          break;
412       }
413       case TX_PRDCTY_MS_10:
414       {
415          periodicityInMsec = 10000;
416          break;
417       }
418       default:
419       {
420          DU_LOG("\nERROR  -->  SCH : Invalid DlUlTxPeriodicity:%d", tddPeriod);
421       }
422    }
423
424    return periodicityInMsec;
425 }
426
427
428 /**
429  * @brief init TDD slot config 
430  *
431  * @details
432  *
433  *     Function : schInitTddSlotCfg 
434  *      
435  *      This API is invoked after receiving schCellCfg
436  *           
437  *  @param[in]  schCellCb *cell
438  *  @param[in]  SchCellCfg *schCellCfg
439  *  @return  void
440  **/
441 void schInitTddSlotCfg(SchCellCb *cell, SchCellCfg *schCellCfg)
442 {
443    uint16_t periodicityInMicroSec = 0;
444    int8_t slotIdx, symbIdx;
445
446    periodicityInMicroSec = schGetPeriodicityInMsec(schCellCfg->tddCfg.tddPeriod);
447    cell->numSlotsInPeriodicity = (periodicityInMicroSec * pow(2, schCellCfg->numerology))/1000;
448    cell->slotFrmtBitMap = 0;
449    cell->symbFrmtBitMap = 0;
450    for(slotIdx = cell->numSlotsInPeriodicity-1; slotIdx >= 0; slotIdx--)
451    {
452       symbIdx = 0;
453       /* If the first and last symbol are the same, the entire slot is the same type */
454       if((schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx] == schCellCfg->tddCfg.slotCfg[slotIdx][MAX_SYMB_PER_SLOT-1]) &&
455               schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx] != FLEXI_SLOT)
456       {
457          switch(schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx])
458          {
459             case DL_SLOT:
460             {
461                /*BitMap to be set to 00 */
462                cell->slotFrmtBitMap = (cell->slotFrmtBitMap<<2);
463                break;
464             }
465             case UL_SLOT:
466             {
467                /*BitMap to be set to 01 */
468                cell->slotFrmtBitMap = ((cell->slotFrmtBitMap<<2) | (UL_SLOT));
469                break;
470             }
471             default:
472                DU_LOG("\nERROR  -->  SCH : Invalid slot Config in schInitTddSlotCfg");
473            }
474          continue;
475       }
476       /* slot config is flexible. First set slotBitMap to 10 */
477       cell->slotFrmtBitMap = ((cell->slotFrmtBitMap<<2) | (FLEXI_SLOT));
478
479       /* Now set symbol bitmap */ 
480       for(symbIdx = MAX_SYMB_PER_SLOT-1; symbIdx >= 0; symbIdx--)
481       {
482          switch(schCellCfg->tddCfg.slotCfg[slotIdx][symbIdx])
483          {
484             case DL_SLOT:
485             {
486                /*symbol BitMap to be set to 00 */
487                cell->symbFrmtBitMap = (cell->symbFrmtBitMap<<2);
488                break;
489             }
490             case UL_SLOT:
491             {
492                /*symbol BitMap to be set to 01 */
493                cell->symbFrmtBitMap = ((cell->symbFrmtBitMap<<2) | (UL_SLOT));
494                break;
495             }
496             case FLEXI_SLOT:
497             {
498                /*symbol BitMap to be set to 10 */
499                cell->symbFrmtBitMap = ((cell->symbFrmtBitMap<<2) | (FLEXI_SLOT));
500                break;
501             }
502             default:
503                DU_LOG("\nERROR  -->  SCH : Invalid slot Config in schInitTddSlotCfg");
504          }
505       }
506    }
507 }
508 #endif
509
510 /**
511  * @brief Fill SSB start symbol
512  *
513  * @details
514  *
515  *     Function : fillSsbStartSymb 
516  *      
517  *      This API stores SSB start index per beam
518  *           
519  *  @param[in]  SchCellCb     *cellCb
520  *  @return  int
521  *      -# ROK 
522  *      -# RFAILED 
523  **/
524 void fillSsbStartSymb(SchCellCb *cellCb)
525 {
526    uint8_t cnt, scs, symbIdx, ssbStartSymbArr[SCH_MAX_SSB_BEAM];
527
528    scs = cellCb->cellCfg.ssbSchCfg.scsCommon;
529
530    memset(ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM));
531    symbIdx = 0;
532    /* Determine value of "n" based on Section 4.1 of 3GPP TS 38.213 */
533    switch(scs)
534    {
535       case SCS_15KHZ:
536          {
537             if(cellCb->cellCfg.dlFreq <= 300000)
538                cnt = 2;/* n = 0, 1 */
539             else
540                cnt = 4; /* n = 0, 1, 2, 3 */
541             for(uint8_t idx=0; idx<cnt; idx++)
542             {
543                /* start symbol determined using {2, 8} + 14n */
544                ssbStartSymbArr[symbIdx++] = 2 +  MAX_SYMB_PER_SLOT*idx;
545                ssbStartSymbArr[symbIdx++] = 8 +  MAX_SYMB_PER_SLOT*idx;
546             }
547          }
548          break;
549       case SCS_30KHZ:
550          {
551             if(cellCb->cellCfg.dlFreq <= 300000)
552                cnt = 1;/* n = 0 */
553             else
554                cnt = 2; /* n = 0, 1 */
555             for(uint8_t idx=0; idx<cnt; idx++)
556             {
557                /* start symbol determined using {4, 8, 16, 20} + 28n */
558                ssbStartSymbArr[symbIdx++] = 4 +  MAX_SYMB_PER_SLOT*idx;
559                ssbStartSymbArr[symbIdx++] = 8 +  MAX_SYMB_PER_SLOT*idx;
560                ssbStartSymbArr[symbIdx++] = 16 +  MAX_SYMB_PER_SLOT*idx;
561                ssbStartSymbArr[symbIdx++] = 20 +  MAX_SYMB_PER_SLOT*idx;
562             }
563          }
564          break;
565       default:
566          DU_LOG("\nERROR  -->  SCH : SCS %d is currently not supported", scs);
567    }
568    memset(cellCb->ssbStartSymbArr, 0, sizeof(SCH_MAX_SSB_BEAM));
569    memcpy(cellCb->ssbStartSymbArr, ssbStartSymbArr, SCH_MAX_SSB_BEAM);
570
571 }
572
573
574 /**
575  * @brief init cellCb based on cellCfg
576  *
577  * @details
578  *
579  *     Function : schInitCellCb 
580  *      
581  *      This API is invoked after receiving schCellCfg
582  *           
583  *  @param[in]  schCellCb *cell
584  *  @param[in]  SchCellCfg *schCellCfg
585  *  @return  int
586  *      -# ROK 
587  *      -# RFAILED 
588  **/
589 uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg)
590 {
591    SchCellCb *cell= NULLP;
592    SCH_ALLOC(cell, sizeof(SchCellCb));
593    if(!cell)
594    {
595       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
596       return RFAILED;
597    }
598
599    cell->cellId = schCellCfg->cellId; 
600    cell->instIdx = inst;
601    switch(schCellCfg->numerology)
602    {
603       case SCH_NUMEROLOGY_0:
604          {
605             cell->numSlots = SCH_MU0_NUM_SLOTS;
606          }
607          break;
608       case SCH_NUMEROLOGY_1:
609          {
610             cell->numSlots = SCH_MU1_NUM_SLOTS;
611          }
612          break;
613       case SCH_NUMEROLOGY_2:
614          {
615             cell->numSlots = SCH_MU2_NUM_SLOTS;
616          }
617          break;
618       case SCH_NUMEROLOGY_3:
619          {
620             cell->numSlots = SCH_MU3_NUM_SLOTS;
621          }
622          break;
623       case SCH_NUMEROLOGY_4:
624          {
625             cell->numSlots = SCH_MU4_NUM_SLOTS;
626          }
627          break;
628       default:
629          DU_LOG("\nERROR  -->  SCH : Numerology %d not supported", schCellCfg->numerology);
630    }
631 #ifdef NR_TDD
632    schInitTddSlotCfg(cell, schCellCfg);   
633 #endif
634
635    SCH_ALLOC(cell->schDlSlotInfo, cell->numSlots * sizeof(SchDlSlotInfo*));
636    if(!cell->schDlSlotInfo)
637    {
638       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb for schDlSlotInfo");
639       return RFAILED;
640    }
641
642    SCH_ALLOC(cell->schUlSlotInfo, cell->numSlots * sizeof(SchUlSlotInfo*));
643    if(!cell->schUlSlotInfo)
644    {
645       DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb for schUlSlotInfo");
646       return RFAILED;
647    }
648
649    for(uint8_t idx=0; idx<cell->numSlots; idx++)
650    {
651       SchDlSlotInfo *schDlSlotInfo;
652       SchUlSlotInfo *schUlSlotInfo;
653
654       /* DL Alloc */
655       SCH_ALLOC(schDlSlotInfo, sizeof(SchDlSlotInfo));
656       if(!schDlSlotInfo)
657       {
658          DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
659          return RFAILED;
660       }
661
662       /* UL Alloc */
663       SCH_ALLOC(schUlSlotInfo, sizeof(SchUlSlotInfo));
664       if(!schUlSlotInfo)
665       {
666          DU_LOG("\nERROR  -->  SCH : Memory allocation failed in schInitCellCb");
667          return RFAILED;
668       }
669
670       schInitDlSlot(schDlSlotInfo);
671       schInitUlSlot(schUlSlotInfo);
672
673       cell->schDlSlotInfo[idx] = schDlSlotInfo;
674       cell->schUlSlotInfo[idx] = schUlSlotInfo;
675
676    }
677    cell->firstSsbTransmitted = false;
678    cell->firstSib1Transmitted = false;
679    fillSsbStartSymb(cell);
680    cmLListInit(&cell->ueToBeScheduled);
681    schCb[inst].cells[inst] = cell;
682
683    DU_LOG("\nINFO  -->  SCH : Cell init completed for cellId:%d", cell->cellId);
684
685    return ROK;   
686 }
687
688 /**
689  * @brief Fill SIB1 configuration
690  *
691  * @details
692  *
693  *     Function : fillSchSib1Cfg
694  *
695  *     Fill SIB1 configuration
696  *
697  *  @param[in]  uint8_t bandwidth : total available bandwidth
698  *              uint8_t numSlots : total slots per SFN
699  *              SchSib1Cfg *sib1SchCfg : cfg to be filled
700  *              uint16_t pci : physical cell Id
701  *              uint8_t offsetPointA : offset
702  *  @return  void
703  **/
704 void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg *sib1SchCfg, uint16_t pci, uint8_t offsetPointA)
705 {
706    uint8_t coreset0Idx = 0;
707    uint8_t searchSpace0Idx = 0;
708    //uint8_t ssbMuxPattern = 0;
709    uint8_t numRbs = 0;
710    uint8_t numSymbols = 0;
711    uint8_t offset = 0;
712    uint8_t oValue = 0;
713    //uint8_t numSearchSpacePerSlot = 0;
714    uint8_t mValue = 0;
715    uint8_t firstSymbol = 0; /* need to calculate using formula mentioned in 38.213 */
716    uint8_t slotIndex = 0;
717    uint8_t FreqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
718    uint16_t tbSize = 0;
719    uint8_t ssbIdx = 0;
720
721    PdcchCfg *pdcch = &(sib1SchCfg->sib1PdcchCfg);
722    PdschCfg *pdsch = &(sib1SchCfg->sib1PdschCfg);
723    BwpCfg *bwp = &(sib1SchCfg->bwp);
724
725    coreset0Idx     = sib1SchCfg->coresetZeroIndex;
726    searchSpace0Idx = sib1SchCfg->searchSpaceZeroIndex;
727
728    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
729    //ssbMuxPattern = coresetIdxTable[coreset0Idx][0];
730    numRbs        = coresetIdxTable[coreset0Idx][1];
731    numSymbols    = coresetIdxTable[coreset0Idx][2];
732    offset        = coresetIdxTable[coreset0Idx][3];
733
734    /* derive the search space params from table 13-11 spec 38.213 */
735    oValue                = searchSpaceIdxTable[searchSpace0Idx][0];
736    //numSearchSpacePerSlot = searchSpaceIdxTable[searchSpace0Idx][1];
737    mValue                = searchSpaceIdxTable[searchSpace0Idx][2];
738    firstSymbol           = searchSpaceIdxTable[searchSpace0Idx][3];
739
740    /* calculate the n0, need to add the formulae, as of now the value is 0 
741     * Need to add the even and odd values of i during configuration 
742     * [(O . 2^u + i . M )  ] mod numSlotsPerSubframe 
743     * assuming u = 0, i = 0, numSlotsPerSubframe = 10
744     * Also, from this configuration, coreset0 is only on even subframe */
745    slotIndex = (int)((oValue*pow(2, mu)) + floor(ssbIdx*mValue))%numSlots;
746    sib1SchCfg->n0 = slotIndex;
747
748    /* fill BWP */
749    switch(bandwidth)
750    {
751       case BANDWIDTH_20MHZ:
752          {
753             bwp->freqAlloc.numPrb = TOTAL_PRB_20MHZ_MU0;
754          }
755          break;
756       case BANDWIDTH_100MHZ:
757          {
758             bwp->freqAlloc.numPrb = TOTAL_PRB_100MHZ_MU1;
759          }
760          break;
761       default:
762          DU_LOG("\nERROR  -->  SCH : Bandwidth %d not supported", bandwidth);
763
764    }
765    bwp->freqAlloc.startPrb = 0;
766    bwp->subcarrierSpacing  = 0;         /* 15Khz */
767    bwp->cyclicPrefix       = 0;              /* normal */
768
769    /* fill the PDCCH PDU */
770    pdcch->coresetCfg.coreSetSize = numRbs;
771    pdcch->coresetCfg.startSymbolIndex = firstSymbol;
772    pdcch->coresetCfg.durationSymbols = numSymbols;
773    
774    /* Fill Bitmap for PRBs in coreset */
775    fillCoresetFeqDomAllocMap(((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource);
776    covertFreqDomRsrcMapToIAPIFormat(FreqDomainResource, pdcch->coresetCfg.freqDomainResource);
777
778    pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
779    pdcch->coresetCfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
780    pdcch->coresetCfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
781    pdcch->coresetCfg.coreSetType = 0;
782    pdcch->coresetCfg.shiftIndex = pci;
783    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
784    pdcch->numDlDci = 1;
785    pdcch->dci.rnti = SI_RNTI;
786    pdcch->dci.scramblingId = pci;
787    pdcch->dci.scramblingRnti = 0;
788    pdcch->dci.cceIndex = 0;
789    pdcch->dci.aggregLevel = 4;
790    pdcch->dci.beamPdcchInfo.numPrgs = 1;
791    pdcch->dci.beamPdcchInfo.prgSize = 1;
792    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
793    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
794    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
795    pdcch->dci.txPdcchPower.powerValue = 0;
796    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
797    /* Storing pdschCfg pointer here. Required to access pdsch config while
798       fillig up pdcch pdu */
799    pdcch->dci.pdschCfg = pdsch; 
800
801    /* fill the PDSCH PDU */
802    uint8_t cwCount = 0;
803    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
804    pdsch->rnti = 0xFFFF; /* SI-RNTI */
805    pdsch->pduIndex = 0;
806    pdsch->numCodewords = 1;
807    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
808    {
809       pdsch->codeword[cwCount].targetCodeRate = 308;
810       pdsch->codeword[cwCount].qamModOrder = 2;
811       pdsch->codeword[cwCount].mcsIndex = sib1SchCfg->sib1Mcs;
812       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
813       pdsch->codeword[cwCount].rvIndex = 0;
814       tbSize = schCalcTbSize(sib1SchCfg->sib1PduLen + TX_PAYLOAD_HDR_LEN);
815       pdsch->codeword[cwCount].tbSize = tbSize;
816    }
817    pdsch->dataScramblingId                   = pci;
818    pdsch->numLayers                          = 1;
819    pdsch->transmissionScheme                 = 0;
820    pdsch->refPoint                           = 0;
821    pdsch->dmrs.dlDmrsSymbPos                 = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
822    pdsch->dmrs.dmrsConfigType                = 0; /* type-1 */
823    pdsch->dmrs.dlDmrsScramblingId            = pci;
824    pdsch->dmrs.scid                          = 0;
825    pdsch->dmrs.numDmrsCdmGrpsNoData          = 1;
826    pdsch->dmrs.dmrsPorts                     = 0x0001;
827    pdsch->dmrs.mappingType                   = DMRS_MAP_TYPE_A; /* Type-A */
828    pdsch->dmrs.nrOfDmrsSymbols               = NUM_DMRS_SYMBOLS;
829    pdsch->dmrs.dmrsAddPos                    = DMRS_ADDITIONAL_POS;
830
831    pdsch->pdschFreqAlloc.resourceAllocType   = 1; /* RAT type-1 RIV format */
832    /* the RB numbering starts from coreset0, and PDSCH is always above SSB */
833    pdsch->pdschFreqAlloc.freqAlloc.startPrb  = offsetPointA + SCH_SSB_NUM_PRB;
834    pdsch->pdschFreqAlloc.freqAlloc.numPrb    = schCalcNumPrb(tbSize,sib1SchCfg->sib1Mcs, NUM_PDSCH_SYMBOL);
835    pdsch->pdschFreqAlloc.vrbPrbMapping       = 0; /* non-interleaved */
836    pdsch->pdschTimeAlloc.rowIndex            = 1;
837    /* This is Intel's requirement. PDSCH should start after PDSCH DRMS symbol */
838    pdsch->pdschTimeAlloc.timeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */
839    pdsch->pdschTimeAlloc.timeAlloc.numSymb   = NUM_PDSCH_SYMBOL;
840    pdsch->beamPdschInfo.numPrgs              = 1;
841    pdsch->beamPdschInfo.prgSize              = 1;
842    pdsch->beamPdschInfo.digBfInterfaces      = 0;
843    pdsch->beamPdschInfo.prg[0].pmIdx         = 0;
844    pdsch->beamPdschInfo.prg[0].beamIdx[0]    = 0;
845    pdsch->txPdschPower.powerControlOffset    = 0;
846    pdsch->txPdschPower.powerControlOffsetSS  = 0;
847
848 }
849
850 /**
851  * @brief cell config from MAC to SCH.
852  *
853  * @details
854  *
855  *     Function : macSchCellCfgReq
856  *      
857  *      This API is invoked by MAC to send cell config to SCH
858  *           
859  *  @param[in]  Pst            *pst
860  *  @param[in]  SchCellCfg     *schCellCfg
861  *  @return  int
862  *      -# ROK 
863  *      -# RFAILED 
864  **/
865 uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg)
866 {
867    uint8_t ret = ROK;
868    SchCellCb *cellCb;
869    SchCellCfgCfm schCellCfgCfm;
870    Pst rspPst;
871    Inst inst = pst->dstInst-1; 
872    uint8_t coreset0Idx = 0;
873    uint8_t numRbs = 0;
874    uint8_t offset = 0;
875    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
876    SchPdschConfig pdschCfg;
877
878 #ifdef CALL_FLOW_DEBUG_LOG
879    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SCH_CELL_CFG\n");
880 #endif 
881
882    schInitCellCb(inst, schCellCfg);
883    cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst
884    cellCb->macInst = pst->srcInst;
885
886    /* derive the SIB1 config parameters */
887    fillSchSib1Cfg(schCellCfg->numerology, schCellCfg->bandwidth, cellCb->numSlots,
888          &(schCellCfg->sib1SchCfg), schCellCfg->phyCellId,
889          schCellCfg->ssbSchCfg.ssbOffsetPointA);
890    memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg));
891
892    /* Fill coreset frequencyDomainResource bitmap */
893    coreset0Idx = cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId;
894    numRbs = coresetIdxTable[coreset0Idx][1];
895    offset = coresetIdxTable[coreset0Idx][3];
896    fillCoresetFeqDomAllocMap(((cellCb->cellCfg.ssbSchCfg.ssbOffsetPointA - offset)/6), (numRbs/6), freqDomainResource);
897    covertFreqDomRsrcMapToIAPIFormat(freqDomainResource, \
898       cellCb->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc);
899
900    /* Fill K0 - K1 table for common cfg*/ 
901    BuildK0K1Table(cellCb, &cellCb->cellCfg.schInitialDlBwp.k0K1InfoTbl, true, cellCb->cellCfg.schInitialDlBwp.pdschCommon,
902    pdschCfg, DEFAULT_UL_ACK_LIST_COUNT, defaultUlAckTbl);
903    
904    BuildK2InfoTable(cellCb, cellCb->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList,\
905    cellCb->cellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc, &cellCb->cellCfg.schInitialUlBwp.msg3K2InfoTbl, \
906    &cellCb->cellCfg.schInitialUlBwp.k2InfoTbl);
907    /* Initializing global variables */
908    cellCb->actvUeBitMap = 0;
909    cellCb->boIndBitMap = 0;
910
911    /* Fill and send Cell config confirm */
912    memset(&rspPst, 0, sizeof(Pst));
913    FILL_PST_SCH_TO_MAC(rspPst, pst->dstInst);
914    rspPst.event = EVENT_SCH_CELL_CFG_CFM;
915
916    schCellCfgCfm.cellId = schCellCfg->cellId; 
917    schCellCfgCfm.rsp = RSP_OK;
918
919    ret = (*SchCellCfgCfmOpts[rspPst.selector])(&rspPst, &schCellCfgCfm);
920    return ret;
921
922 }
923
924 /*******************************************************************
925  *
926  * @brief Processes DL RLC BO info from MAC
927  *
928  * @details
929  *
930  *    Function : MacSchDlRlcBoInfo
931  *
932  *    Functionality:
933  *       Processes DL RLC BO info from MAC
934  *
935  * @params[in] 
936  * @return ROK     - success
937  *         RFAILED - failure
938  *
939  * ****************************************************************/
940 uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo)
941 {
942    uint8_t  lcId = 0;
943    uint16_t ueId = 0;
944    bool isLcIdValid = false;
945    SchUeCb *ueCb = NULLP;
946    SchCellCb *cell = NULLP;
947    Inst  inst = pst->dstInst-SCH_INST_START;
948    CmLListCp *lcLL = NULLP;
949
950 #ifdef CALL_FLOW_DEBUG_LOG
951    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n");
952 #endif
953
954    DU_LOG("\nDEBUG  -->  SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume);
955    cell = schCb[inst].cells[inst];
956
957    if(cell == NULLP)
958    {
959       DU_LOG("\nERROR  -->  SCH : MacSchDlRlcBoInfo(): Cell does not exists");
960       return RFAILED;
961    }
962
963    GET_UE_ID(dlBoInfo->crnti, ueId);
964    ueCb = &cell->ueCb[ueId-1];
965    lcId  = dlBoInfo->lcId;
966    CHECK_LCID(lcId, isLcIdValid);
967    if(isLcIdValid == FALSE)
968    {
969       DU_LOG("ERROR --> SCH: LCID:%d is not valid", lcId);
970       return RFAILED;
971    }
972
973    /*Expected when theres a case of Retransmission Failure or Resetablishment
974     *By Zero BO, the RLC is informing that previous data can be cleared out
975     *Thus clearing out the LC from the Lc priority list*/
976    if(dlBoInfo->dataVolume == 0)
977    {
978       /*Check the LC is Dedicated or default and accordingly LCList will
979        * be used*/
980       if(ueCb->dlInfo.dlLcCtxt[lcId].isDedicated)
981       {
982          lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList);
983       }
984       else
985       {
986          lcLL = &(ueCb->dlLcPrbEst.defLcList);
987       }
988       handleLcLList(lcLL, lcId, DELETE);
989       return ROK;
990    }
991
992    if(lcId == SRB0_LCID)
993    {
994       cell->raCb[ueId -1].msg4recvd = true;
995       cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume;
996       
997    }
998    else
999    {
1000       /* TODO : These part of changes will be corrected during DL scheduling as
1001        * per K0 - K1 -K2 */
1002       SET_ONE_BIT(ueId, cell->boIndBitMap);
1003       if(ueCb->dlInfo.dlLcCtxt[lcId].lcId == lcId)
1004       {
1005          ueCb->dlInfo.dlLcCtxt[lcId].bo = dlBoInfo->dataVolume;
1006       }
1007       else
1008       {
1009          DU_LOG("ERROR --> SCH: LCID:%d is not configured in SCH Cb",lcId);
1010          return RFAILED;
1011       }
1012    }
1013    
1014    /* Adding UE Id to list of pending UEs to be scheduled */
1015    addUeToBeScheduled(cell, ueId);
1016    return ROK;
1017 }
1018
1019 /*******************************************************************
1020  *
1021  * @brief Processes BSR indiation from MAC
1022  *
1023  * @details
1024  *
1025  *    Function : MacSchBsr
1026  *
1027  *    Functionality:
1028  *       Processes DL BSR from MAC
1029  *
1030  * @params[in]    Pst pst
1031  *                UlBufferStatusRptInd bsrInd
1032  * @return ROK     - success
1033  *         RFAILED - failure
1034  *
1035  * ****************************************************************/
1036 uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd)
1037 {
1038    Inst           schInst       = pst->dstInst-SCH_INST_START;
1039    SchCellCb      *cellCb       = NULLP;
1040    SchUeCb        *ueCb         = NULLP;
1041    uint8_t        lcgIdx = 0;
1042
1043 #ifdef CALL_FLOW_DEBUG_LOG
1044    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n");
1045 #endif
1046
1047    DU_LOG("\nDEBUG  -->  SCH : Received BSR");
1048    if(bsrInd == NULLP)
1049    {
1050       DU_LOG("\nERROR  -->  SCH : BSR Ind is empty");
1051       return RFAILED;
1052    }
1053    cellCb = schCb[schInst].cells[schInst];
1054    if(cellCb == NULLP)
1055    {
1056       DU_LOG("\nERROR  -->  SCH : CellCb is empty");
1057       return RFAILED;
1058    }
1059    ueCb = schGetUeCb(cellCb, bsrInd->crnti);
1060
1061    if(ueCb == NULLP)
1062    {
1063       DU_LOG("\nERROR  -->  SCH : UeCB is empty");
1064       return RFAILED;
1065    }
1066
1067    ueCb->bsrRcvd = true;
1068    /* store dataVolume per lcg in uecb */
1069    for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++)
1070    {
1071       ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].priority = 1; //TODO: determining LCG priority?
1072       ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol;
1073    }
1074    
1075    /* Adding UE Id to list of pending UEs to be scheduled */
1076    addUeToBeScheduled(cellCb, ueCb->ueId);
1077    return ROK;
1078 }
1079
1080 /*******************************************************************
1081  *
1082  * @brief Processes SR UCI indication from MAC 
1083  *
1084  * @details
1085  *
1086  *    Function : MacSchSrUciInd
1087  *
1088  *    Functionality:
1089  *      Processes SR UCI indication from MAC
1090  *
1091  * @params[in] Post structure
1092  *             UCI Indication
1093  * @return ROK     - success
1094  *         RFAILED - failure
1095  *
1096  * ****************************************************************/
1097 uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd)
1098 {
1099    Inst  inst = pst->dstInst-SCH_INST_START;
1100
1101    SchUeCb   *ueCb; 
1102    SchCellCb *cellCb = schCb[inst].cells[inst];
1103
1104 #ifdef CALL_FLOW_DEBUG_LOG
1105    DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UCI_IND_TO_SCH\n");
1106 #endif
1107
1108    DU_LOG("\nDEBUG  -->  SCH : Received SR");
1109
1110    ueCb = schGetUeCb(cellCb, uciInd->crnti);
1111    
1112    if(ueCb->state == SCH_UE_STATE_INACTIVE)
1113    {
1114       DU_LOG("\nERROR  -->  SCH : Crnti %d is inactive", uciInd->crnti);
1115       return ROK;  
1116    }
1117
1118    if(uciInd->numSrBits)
1119    {
1120       ueCb->srRcvd = true;
1121       
1122       /* Adding UE Id to list of pending UEs to be scheduled */
1123       addUeToBeScheduled(cellCb, ueCb->ueId);
1124    }
1125    return ROK;
1126 }
1127
1128 /*******************************************************************
1129  *
1130  * @brief Allocates requested PRBs for DL
1131  *
1132  * @details
1133  *
1134  *    Function : allocatePrbDl
1135  *
1136  *    Functionality:
1137  *      Allocates requested PRBs in DL
1138  *      Keeps track of allocated PRB (using bitmap) and remaining PRBs
1139  *
1140  * @params[in] prbAlloc table
1141  *             Start symbol
1142  *             Number of symbols
1143  *             Start PRB
1144  *             Number of PRBs
1145  *
1146  * @return ROK     - success
1147  *         RFAILED - failure
1148  *
1149  * ****************************************************************/
1150 uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, \
1151    uint8_t startSymbol, uint8_t symbolLength, uint16_t *startPrb, uint16_t numPrb)
1152 {
1153    uint8_t        symbol = 0;
1154    uint16_t       broadcastPrbStart=0, broadcastPrbEnd=0;
1155    FreePrbBlock   *freePrbBlock = NULLP;
1156    CmLList        *freePrbNode = NULLP;
1157    PduTxOccsaion  ssbOccasion=0, sib1Occasion=0;
1158    SchDlSlotInfo  *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
1159    SchPrbAlloc    *prbAlloc = &schDlSlotInfo->prbAlloc;
1160
1161    /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently.
1162     * Search for an appropriate location in PRB grid and allocate requested resources */
1163    if(*startPrb == MAX_NUM_RB)
1164    {
1165       /* Check if SSB/SIB1 is also scheduled in this slot  */
1166       ssbOccasion = schCheckSsbOcc(cell, slotTime);
1167       sib1Occasion = schCheckSib1Occ(cell, slotTime);
1168
1169       if(ssbOccasion && sib1Occasion)
1170       {
1171          broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; 
1172          broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1;
1173       }
1174       else if(ssbOccasion)
1175       {
1176          broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA;
1177          broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1;
1178       }
1179       else if(sib1Occasion)
1180       {
1181          broadcastPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb;
1182          broadcastPrbEnd = broadcastPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1;
1183       }
1184
1185       /* Iterate through all free PRB blocks */
1186       freePrbNode = prbAlloc->freePrbBlockList.first; 
1187       while(freePrbNode)
1188       {
1189          freePrbBlock = (FreePrbBlock *)freePrbNode->node; 
1190
1191          /* If broadcast message is scheduled in this slot, then check if its PRBs belong to the current free block.
1192           * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */
1193          if((ssbOccasion || sib1Occasion) && 
1194             ((broadcastPrbStart >= freePrbBlock->startPrb) && (broadcastPrbStart <= freePrbBlock->endPrb)) && \
1195             ((broadcastPrbEnd >= freePrbBlock->startPrb) && (broadcastPrbEnd <= freePrbBlock->endPrb)))
1196          {
1197             /* Implmentation is done such that highest-numbered free-RB is allocated first */ 
1198             if((freePrbBlock->endPrb > broadcastPrbEnd) && ((freePrbBlock->endPrb - broadcastPrbEnd) >= numPrb))
1199             {
1200                /* If sufficient free PRBs are available above bradcast message then,
1201                 * endPrb = freePrbBlock->endPrb
1202                 * startPrb = endPrb - numPrb +1;
1203                 */
1204                *startPrb = freePrbBlock->endPrb - numPrb +1;
1205                break;
1206             }
1207             else if((broadcastPrbStart > freePrbBlock->startPrb) && ((broadcastPrbStart - freePrbBlock->startPrb) >= numPrb))
1208             {
1209                /* If free PRBs are available below broadcast message then,
1210                 * endPrb = broadcastPrbStart - 1
1211                 * startPrb = endPrb - numPrb +1
1212                 */
1213                *startPrb = broadcastPrbStart - numPrb; 
1214                break;
1215             }
1216             else
1217             {
1218                freePrbNode = freePrbNode->next;
1219                continue;
1220             }
1221          }
1222          else
1223          {
1224             /* Check if requested number of blocks can be allocated from the current block */ 
1225             if (freePrbBlock->numFreePrb < numPrb)
1226             {
1227                freePrbNode = freePrbNode->next;
1228                continue;
1229             }
1230             *startPrb = freePrbBlock->endPrb - numPrb +1;
1231             break;  
1232          }
1233       }
1234
1235       /* If no free block can be used to allocated request number of RBs */
1236       if(*startPrb == MAX_NUM_RB)
1237          return RFAILED;
1238    }
1239
1240    /* If startPrb is known already, check if requested PRBs are available for allocation */
1241    else
1242    {
1243       freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
1244       if(!freePrbNode)
1245       {
1246          DU_LOG("\nERROR  -->  SCH: Requested DL PRB unavailable");
1247          return RFAILED;
1248       }
1249    }
1250
1251    /* Update bitmap to allocate PRBs */
1252    for(symbol=startSymbol; symbol < (startSymbol+symbolLength); symbol++)
1253    {
1254       if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
1255       {
1256          DU_LOG("\nERROR  -->  SCH: fillPrbBitmap() failed for symbol [%d] in DL", symbol);
1257          return RFAILED;
1258       }
1259    }
1260
1261    /* Update the remaining number for free PRBs */
1262    removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb);
1263
1264    return ROK;
1265 }
1266
1267 /*******************************************************************
1268  *
1269  * @brief Allocates requested PRBs for UL
1270  *
1271  * @details
1272  *
1273  *    Function : allocatePrbUl
1274  *
1275  *    Functionality:
1276  *      Allocates requested PRBs in UL
1277  *      Keeps track of allocated PRB (using bitmap) and remaining PRBs
1278  *
1279  * @params[in] prbAlloc table
1280  *             Start symbol
1281  *             Number of symbols
1282  *             Start PRB
1283  *             Number of PRBs
1284  *
1285  * @return ROK     - success
1286  *         RFAILED - failure
1287  *
1288  * ****************************************************************/
1289 uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \
1290    uint8_t startSymbol, uint8_t symbolLength, uint16_t *startPrb, uint16_t numPrb)
1291 {
1292    uint8_t        symbol = 0;
1293    uint16_t       prachStartPrb, prachNumPrb, prachEndPrb;
1294    bool           isPrachOccasion;
1295    FreePrbBlock   *freePrbBlock = NULLP;
1296    CmLList        *freePrbNode = NULLP;
1297    SchPrbAlloc    *prbAlloc = NULLP;
1298
1299    if(cell == NULLP)
1300    {
1301       DU_LOG("\nERROR  --> SCH : allocatePrbUl(): Received cellCb is null");
1302       return RFAILED;
1303    }
1304    
1305    prbAlloc =   &cell->schUlSlotInfo[slotTime.slot]->prbAlloc;
1306    /* If startPrb is set to MAX_NUM_RB, it means startPrb is not known currently.
1307     * Search for an appropriate location in PRB grid and allocate requested resources */
1308    if(*startPrb == MAX_NUM_RB)
1309    {
1310       /* Check if PRACH is also scheduled in this slot */
1311       isPrachOccasion = schCheckPrachOcc(cell, slotTime);
1312       if(isPrachOccasion)
1313       {
1314          prachStartPrb =  cell->cellCfg.schRachCfg.msg1FreqStart;
1315          prachNumPrb = schCalcPrachNumRb(cell);
1316          prachEndPrb = prachStartPrb + prachNumPrb -1;
1317       }
1318
1319       /* Iterate through all free PRB blocks */
1320       freePrbNode = prbAlloc->freePrbBlockList.first; 
1321       while(freePrbNode)
1322       {
1323          freePrbBlock = (FreePrbBlock *)freePrbNode->node; 
1324
1325          /* If PRACH is scheduled in this slot, then check if its PRBs belong to the current free block.
1326           * PRBs required for PRACH cannot be allocated to any other message */
1327          if((isPrachOccasion) &&
1328             ((prachStartPrb >= freePrbBlock->startPrb) && (prachStartPrb <= freePrbBlock->endPrb)) &&
1329             ((prachEndPrb >= freePrbBlock->startPrb) && (prachEndPrb <= freePrbBlock->endPrb)))
1330          {
1331             /* Implmentation is done such that highest-numbered free-RB is allocated first */ 
1332             if((freePrbBlock->endPrb > prachEndPrb) && ((freePrbBlock->endPrb - prachEndPrb) >= numPrb))
1333             {
1334                /* If sufficient free PRBs are available above PRACH message then,
1335                 * endPrb = freePrbBlock->endPrb
1336                 * startPrb = endPrb - numPrb +1;
1337                 */
1338                *startPrb = freePrbBlock->endPrb - numPrb +1;
1339                break;
1340             }
1341             else if((prachStartPrb > freePrbBlock->startPrb) && ((prachStartPrb - freePrbBlock->startPrb) >= numPrb))
1342             {
1343                /* If free PRBs are available below PRACH message then,
1344                 * endPrb = prachStartPrb - 1
1345                 * startPrb = endPrb - numPrb +1
1346                 */
1347                *startPrb = prachStartPrb - numPrb; 
1348                break;
1349             }
1350             else
1351             {
1352                freePrbNode = freePrbNode->next;
1353                continue;
1354             } 
1355          }
1356          else
1357          {
1358             /* Check if requested number of PRBs can be allocated from currect block */
1359             if(freePrbBlock->numFreePrb < numPrb)
1360             {
1361                freePrbNode = freePrbNode->next;
1362                continue;
1363             }
1364             *startPrb = freePrbBlock->endPrb - numPrb +1;
1365             break;
1366          }
1367       }
1368
1369       /* If no free block can be used to allocated requested number of RBs */
1370       if(*startPrb == MAX_NUM_RB)
1371          return RFAILED;
1372    }
1373    else
1374    {
1375       /* If startPrb is known already, check if requested PRBs are available for allocation */
1376       freePrbNode = isPrbAvailable(&prbAlloc->freePrbBlockList, *startPrb, numPrb);
1377       if(!freePrbNode)
1378       {
1379          DU_LOG("\nERROR  -->  SCH: Requested UL PRB unavailable");
1380          return RFAILED;
1381       }
1382    }
1383
1384    /* Update bitmap to allocate PRBs */
1385    for(symbol=startSymbol; symbol < (startSymbol+symbolLength); symbol++)
1386    {
1387       if(fillPrbBitmap(prbAlloc->prbBitMap[symbol], *startPrb, numPrb) != ROK)
1388       {
1389          DU_LOG("\nERROR  -->  SCH: fillPrbBitmap() failed for symbol [%d] in UL", symbol);
1390          return RFAILED;
1391       }
1392    }
1393
1394    /* Update the remaining number for free PRBs */
1395    removeAllocatedPrbFromFreePrbList(&prbAlloc->freePrbBlockList, freePrbNode, *startPrb, numPrb);
1396
1397    return ROK;
1398 }
1399
1400 /*******************************************************************
1401  *
1402  * @brief Add UE to ueToBeScheduled List
1403  *
1404  * @details
1405  *
1406  *    Function : addUeToBeScheduled
1407  *
1408  *    Functionality:
1409  *      Search if UE entry present in the list
1410  *      If yes, return.
1411  *      If no, add UE to the list
1412  *
1413  * @params[in] Cell control block
1414  *             Ue Idx to be added
1415  *
1416  * @return ROK     - success
1417  *         RFAILED - failure
1418  *
1419  * ****************************************************************/
1420 uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd)
1421 {
1422    uint8_t *ueId;
1423    CmLList *node;
1424
1425    /* Search if UE entry is already present in ueToBeScheduled list.
1426     * If yes, another entry for same UE not needed. Hence, return */
1427    node = cell->ueToBeScheduled.first;
1428    while(node)
1429    {
1430       ueId = (uint8_t *)node->node;
1431       if(*ueId == ueIdToAdd)
1432          return ROK;
1433       node = node->next;
1434    }
1435
1436    /* If UE entry not present already, add UE to the end of ueToBeScheduled list */
1437    SCH_ALLOC(ueId, sizeof(uint8_t));
1438    if(!ueId)
1439    {
1440       DU_LOG("\nERROR  -->  SCH : Memory allocation failure in addUeToBeScheduled");
1441       return RFAILED;
1442    }
1443    *ueId = ueIdToAdd;
1444    if(addNodeToLList(&cell->ueToBeScheduled, ueId, NULLP) != ROK)
1445    {
1446       DU_LOG("\nERROR  --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
1447       return RFAILED;
1448    }
1449    return ROK;
1450 }
1451  
1452 /*******************************************************************************
1453  *
1454  * @brief Try to find Best Free Block with Max Num PRB 
1455  *
1456  * @details
1457  *
1458  *    Function : searchLargestFreeBlock
1459  *
1460  *    Functionality:
1461  *     Finds the FreeBlock with MaxNum of FREE PRB considering SSB/SIB1 ocassions.
1462  *
1463  * @params[in] I/P > prbAlloc table (FreeBlock list)
1464  *             I/P > Slot timing Info
1465  *             O/P > Start PRB
1466  *             I/P > Direction (UL/DL)
1467  *       
1468  *
1469  * @return Max Number of Free PRB 
1470  *         If 0, then no Suitable Free Block
1471  *
1472  * ********************************************************************************/
1473
1474 uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir)
1475 {
1476    uint16_t       reservedPrbStart=0, reservedPrbEnd=0, maxFreePRB = 0;
1477    FreePrbBlock   *freePrbBlock = NULLP;
1478    CmLList        *freePrbNode = NULLP;
1479    SchPrbAlloc    *prbAlloc = NULLP;
1480    bool           checkOccasion = FALSE;
1481
1482    *startPrb = 0; /*Initialize the StartPRB to zero*/
1483
1484    /*Based on Direction, Reserved Messsages will differi.e.
1485     * DL >> SSB and SIB1 ocassions wheres for UL, PRACH ocassions to be checked
1486     * and reserved before allocation for dedicated DL/UL msg*/
1487    if(dir == DIR_DL)
1488    {
1489       SchDlSlotInfo  *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot];
1490       PduTxOccsaion  ssbOccasion=0, sib1Occasion=0;
1491
1492       prbAlloc = &schDlSlotInfo->prbAlloc;
1493
1494       ssbOccasion = schCheckSsbOcc(cell, slotTime);
1495       sib1Occasion = schCheckSib1Occ(cell, slotTime);
1496
1497       checkOccasion = TRUE;
1498       if(ssbOccasion && sib1Occasion)
1499       {
1500          reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; 
1501          reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \
1502                           cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1;
1503       }
1504       else if(ssbOccasion)
1505       {
1506          reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA;
1507          reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1;
1508       }
1509       else if(sib1Occasion)
1510       {
1511          reservedPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb;
1512          reservedPrbEnd = reservedPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1;
1513       }
1514       else
1515       {
1516          checkOccasion = FALSE;  
1517       }
1518    }
1519    else if(dir == DIR_UL)
1520    {
1521       prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc;
1522
1523       /* Check if PRACH is also scheduled in this slot */
1524       checkOccasion = schCheckPrachOcc(cell, slotTime);
1525       if(checkOccasion)
1526       {
1527          reservedPrbStart =  cell->cellCfg.schRachCfg.msg1FreqStart;
1528          reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1;
1529       }
1530    }
1531    else
1532    {
1533       DU_LOG("\nERROR --> SCH: Invalid Direction!");
1534       return (maxFreePRB);
1535    }
1536
1537    freePrbNode = prbAlloc->freePrbBlockList.first; 
1538    while(freePrbNode)
1539    {
1540       freePrbBlock = (FreePrbBlock *)freePrbNode->node;
1541
1542       /*For block with same numFreeBlocks, choose the one with HighestPRB range
1543        *Since FreeBLockList are arranged in Descending order of PRB range thus Skipping this block*/
1544       if(maxFreePRB >= freePrbBlock->numFreePrb) 
1545       {
1546          //skip this block
1547          freePrbNode = freePrbNode->next;
1548          continue;
1549       }
1550
1551       /* If Broadcast/Prach message is scheduled in this slot, then check if its PRBs belong to the current free block.
1552        * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */
1553       if(checkOccasion && 
1554             ((reservedPrbStart >= freePrbBlock->startPrb) && (reservedPrbStart <= freePrbBlock->endPrb)) && \
1555             ((reservedPrbEnd >= freePrbBlock->startPrb) && (reservedPrbEnd <= freePrbBlock->endPrb)))
1556       {
1557
1558          /* Implmentation is done such that highest-numbered free-RB is Checked first
1559             and freePRB in this block is greater than Max till now */
1560          if((freePrbBlock->endPrb > reservedPrbEnd) && ((freePrbBlock->endPrb - reservedPrbEnd) > maxFreePRB))
1561          {
1562             /* If sufficient free PRBs are available above reserved message*/
1563             *startPrb = reservedPrbEnd + 1;
1564             maxFreePRB = (freePrbBlock->endPrb - reservedPrbEnd);                
1565          }
1566          /*Also check the other freeBlock (i.e. Above the reserved message) for MAX FREE PRB*/
1567          if((reservedPrbStart > freePrbBlock->startPrb) && ((reservedPrbStart - freePrbBlock->startPrb) > maxFreePRB))
1568          {
1569             /* If free PRBs are available below reserved message*/
1570             *startPrb = freePrbBlock->startPrb;
1571             maxFreePRB = (reservedPrbStart - freePrbBlock->startPrb);
1572          }
1573       }
1574       else  //Best Block
1575       {
1576          if(maxFreePRB < freePrbBlock->numFreePrb)
1577          {
1578             *startPrb = freePrbBlock->startPrb;
1579             maxFreePRB = freePrbBlock->numFreePrb;
1580          }
1581
1582       }
1583       freePrbNode = freePrbNode->next;
1584    }  
1585    return(maxFreePRB);
1586 }
1587
1588 /*******************************************************************************
1589  *
1590  * @brief This function is used to send Slice Cfg rsp to MAC
1591  *
1592  * @details
1593  *
1594  *    Function : SchSendSliceCfgRspToMac
1595  *
1596  *    Functionality:
1597  *     function is used to send Slice Cfg rsp to MAC
1598  *
1599  * @params[in] Pst *pst, SchSliceCfgRsp sliceCfgRsp
1600  *
1601  * @return- void
1602  *
1603  * ********************************************************************************/
1604 void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp)
1605 {
1606    Pst rspPst;
1607    
1608    memset(&rspPst, 0, sizeof(Pst));
1609    FILL_PST_SCH_TO_MAC(rspPst, inst);
1610    rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC;
1611    
1612    SchSliceCfgRspOpts[rspPst.selector](&rspPst, &sliceCfgRsp);
1613
1614 }
1615 /*******************************************************************************
1616  *
1617  * @brief fill slice configuration response
1618  *
1619  * @details
1620  *
1621  *    Function : fillSliceCfgRsp
1622  *
1623  *    Functionality:
1624  *     fill slice configuration response
1625  *
1626  * @params[in] SchCellCb, SchSliceCfgReq, SchSliceCfgRsp,uint8_t  count
1627  *
1628  * @return
1629  *        ROK - Success
1630  *        RFAILED - Failure
1631  *
1632  * ********************************************************************************/
1633 uint8_t fillSliceCfgRsp(bool sliceReCfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count)
1634 {
1635    bool sliceFound = false;
1636    uint8_t cfgIdx = 0, sliceIdx = 0;
1637
1638    schSliceCfgRsp->numSliceCfgRsp  = schSliceCfgReq->numOfConfiguredSlice;
1639    SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
1640    if(schSliceCfgRsp->listOfSliceCfgRsp == NULLP)
1641    {
1642       DU_LOG("\nERROR  --> SCH : Memory allocation failed at fillSliceCfgRsp");
1643       return RFAILED;
1644    }
1645    
1646    for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp ; cfgIdx++)
1647    {
1648       sliceFound = false;
1649       /* Here comparing the slice cfg request with the slice stored in cellCfg */
1650       if(sliceReCfg != true)
1651       {
1652          for(sliceIdx = 0; sliceIdx<cellCb->cellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
1653          {
1654             if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, cellCb->cellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai)))
1655             {
1656                (*count)++;
1657                sliceFound = true;
1658                break;
1659             }
1660          }
1661       }
1662       else
1663       {
1664          /* Here comparing the slice cfg request with the slice stored in SchDb */
1665          if(storedSliceCfg->listOfConfirguration)
1666          {
1667             for(sliceIdx = 0; sliceIdx<storedSliceCfg->numOfSliceConfigured; sliceIdx++)
1668             {
1669                if(!memcmp(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, &storedSliceCfg->listOfConfirguration[sliceIdx]->snssai,\
1670                         sizeof(Snssai)))
1671                {
1672                   (*count)++;
1673                   sliceFound = true;
1674                   break;
1675                }
1676             }
1677          }
1678       }
1679
1680       SCH_ALLOC(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
1681       if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
1682       {
1683          DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in fillSliceCfgRsp");
1684          return RFAILED;
1685       }
1686
1687       
1688       schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai;
1689       if(sliceFound == true)
1690          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = RSP_OK;
1691       else
1692       {
1693          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = RSP_NOK;
1694          schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause  = SLICE_NOT_FOUND;
1695       }
1696    }
1697    return ROK;
1698 }
1699
1700 /*******************************************************************************
1701  *
1702  * @brief This function is used to store the slice configuration Sch DB
1703  *
1704  * @details
1705  *
1706  *    Function : addSliceCfgInSchDb 
1707  *
1708  *    Functionality:
1709  *     function is used to store the slice configuration Sch DB
1710  *
1711  * @params[in] SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq,
1712  * SchSliceCfgRsp cfgRsp, uint8_t count
1713  *
1714  * @return
1715  *        ROK - Success
1716  *        RFAILED - Failure
1717  *
1718  * ********************************************************************************/
1719 uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count)
1720 {
1721    uint8_t cfgIdx = 0, sliceIdx = 0; 
1722    
1723    if(count)
1724    {
1725       storeSliceCfg->numOfSliceConfigured = count;
1726       SCH_ALLOC(storeSliceCfg->listOfConfirguration, storeSliceCfg->numOfSliceConfigured * sizeof(SchRrmPolicyOfSlice*));
1727       if(storeSliceCfg->listOfConfirguration == NULLP)
1728       {
1729          DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in addSliceCfgInSchDb");
1730          return RFAILED;
1731       }
1732
1733       for(cfgIdx = 0; cfgIdx<storeSliceCfg->numOfSliceConfigured; cfgIdx++)
1734       {
1735          if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
1736          {
1737             SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice));
1738             if(storeSliceCfg->listOfConfirguration[sliceIdx] == NULLP)
1739             {
1740                DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in addSliceCfgInSchDb");
1741                return RFAILED;
1742             }
1743
1744             SCH_ALLOC(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio));
1745             if(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo == NULLP)
1746             {
1747                DU_LOG("\nERROR  -->  SCH : Failed to allocate memory in addSliceCfgInSchDb");
1748                return RFAILED;
1749             }
1750
1751             memcpy(storeSliceCfg->listOfConfirguration[sliceIdx], cfgReq->listOfConfirguration[sliceIdx], sizeof(SchRrmPolicyOfSlice));
1752             sliceIdx++;
1753          }
1754       }
1755    }
1756    return ROK;
1757 }
1758
1759 /*******************************************************************************
1760  *
1761  * @brief This function is used to free the slice cfg and re cfg request pointer
1762  *
1763  * @details
1764  *
1765  *    Function : freeSchSliceCfgReq 
1766  *
1767  *    Functionality:
1768  *     function is used to free the slice cfg and re cfg request pointer
1769  *
1770  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1771  *
1772  * @return
1773  *        ROK - Success
1774  *        RFAILED - Failure
1775  * ********************************************************************************/
1776 void freeSchSliceCfgReq(SchSliceCfgReq *cfgReq)
1777 {
1778    uint8_t cfgIdx = 0;
1779    
1780    if(cfgReq)
1781    {
1782       if(cfgReq->numOfConfiguredSlice)
1783       {
1784          for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
1785          {
1786             if(cfgReq->listOfConfirguration[cfgIdx])
1787             {
1788                SCH_FREE(cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio));
1789                SCH_FREE(cfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice));
1790             }
1791          }
1792          SCH_FREE(cfgReq->listOfConfirguration, cfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*));
1793       }
1794       SCH_FREE(cfgReq, sizeof(SchSliceCfgReq));
1795    }
1796 }
1797 /*******************************************************************************
1798  *
1799  * @brief This function is used to store the slice configuration Sch DB
1800  *
1801  * @details
1802  *
1803  *    Function : MacSchSliceCfgReq 
1804  *
1805  *    Functionality:
1806  *     function is used to store the slice configuration Sch DB
1807  *
1808  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1809  *
1810  * @return
1811  *        ROK - Success
1812  *        RFAILED - Failure
1813  *
1814  * ********************************************************************************/
1815 uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq)
1816 {
1817    uint8_t count = 0;
1818    Inst   inst = pst->dstInst - 1;
1819    SchSliceCfgRsp sliceCfgRsp;
1820
1821    DU_LOG("\nINFO  -->  SCH : Received Slice Cfg request from MAC");
1822    if(schSliceCfgReq)
1823    {
1824       if(schSliceCfgReq->listOfConfirguration)
1825       {
1826          /* filling the slice configuration response of each slice */
1827          if(fillSliceCfgRsp(false, NULLP, schCb[inst].cells[0], schSliceCfgReq, &sliceCfgRsp, &count) != ROK)
1828          {
1829             DU_LOG("\nERROR  -->  SCH : Failed to fill the slice cfg rsp");
1830             return RFAILED;
1831          }
1832
1833          if(addSliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceCfgReq, sliceCfgRsp, count) != ROK)
1834          {
1835             DU_LOG("\nERROR  -->  SCH : Failed to add slice cfg in sch database");
1836             return RFAILED;
1837          }
1838          freeSchSliceCfgReq(schSliceCfgReq);
1839          SchSendSliceCfgRspToMac(inst, sliceCfgRsp);
1840       }
1841    }
1842    else
1843    {
1844       DU_LOG("\nERROR  -->  SCH : Received SchSliceCfgReq is NULL");
1845    }
1846    return ROK;
1847 }
1848
1849 /*******************************************************************************
1850  *
1851  * @brief This function is used to store the slice reconfiguration Sch DB
1852  *
1853  * @details
1854  *
1855  *    Function : modifySliceCfgInSchDb 
1856  *
1857  *    Functionality:
1858  *     function is used to store the slice re configuration Sch DB
1859  *
1860  * @params[in] Pst *pst, SchSliceCfgReq *schSliceCfgReq
1861  *
1862  * @return
1863  *        ROK - Success
1864  *        RFAILED - Failure
1865  *
1866  * ********************************************************************************/
1867 uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count)
1868 {
1869    uint8_t cfgIdx = 0, sliceIdx = 0; 
1870
1871    if(count)
1872    {
1873       if(storeSliceCfg->listOfConfirguration == NULLP)
1874       {
1875          DU_LOG("\nINFO  -->  SCH : Memory allocation failed in modifySliceCfgInSchDb");
1876          return RFAILED;
1877       }
1878
1879       for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
1880       {
1881          if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
1882          {
1883             for(sliceIdx = 0; sliceIdx<storeSliceCfg->numOfSliceConfigured; sliceIdx++)
1884             {
1885                if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai)))
1886                {
1887                   storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo = cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo;
1888                   break;
1889                }
1890             }
1891          }
1892       }
1893    }
1894    freeSchSliceCfgReq(cfgReq);
1895    return ROK;
1896 }
1897 /*******************************************************************************
1898  *
1899  * @brief This function is used to send Slice re Cfg rsp to MAC
1900  *
1901  * @details
1902  *
1903  *    Function : SchSendSliceCfgRspToMac
1904  *
1905  *    Functionality:
1906  *     function is used to send Slice re Cfg rsp to MAC
1907  *
1908  * @params[in] Pst *pst, SchSliceCfgRsp schSliceReCfgRsp
1909  *
1910  * @return- void
1911  *
1912  * ********************************************************************************/
1913 void SchSendSliceReCfgRspToMac(Inst inst, SchSliceCfgRsp schSliceReCfgRsp)
1914 {
1915    Pst rspPst;
1916    
1917    memset(&rspPst, 0, sizeof(Pst));
1918    FILL_PST_SCH_TO_MAC(rspPst, inst);
1919    rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC;
1920    
1921    SchSliceReCfgRspOpts[rspPst.selector](&rspPst, &schSliceReCfgRsp);
1922 }
1923 /*******************************************************************************
1924  *
1925  * @brief This function is used to store the slice reconfiguration Sch DB
1926  *
1927  * @details
1928  *
1929  *    Function : MacSchSliceReCfgReq 
1930  *
1931  *    Functionality:
1932  *     function is used to store the slice re configuration Sch DB
1933  *
1934  * @params[in] Pst *pst, SchSliceCfgReq *schSliceReCfgReq
1935  *
1936  * @return
1937  *        ROK - Success
1938  *        RFAILED - Failure
1939  *
1940  * ********************************************************************************/
1941 uint8_t MacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *schSliceReCfgReq)
1942 {
1943    uint8_t count = 0;
1944    Inst   inst = pst->dstInst - 1;
1945    SchSliceCfgRsp schSliceReCfgRsp;
1946
1947    DU_LOG("\nINFO  -->  SCH : Received Slice ReCfg request from MAC");
1948    if(schSliceReCfgReq)
1949    {
1950       if(schSliceReCfgReq->listOfConfirguration)
1951       {
1952          /* filling the slice configuration response of each slice */
1953          if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceReCfgReq, &schSliceReCfgRsp, &count) != ROK)
1954          {
1955             DU_LOG("\nERROR  -->  SCH : Failed to fill sch slice cfg response");
1956             return RFAILED;
1957          }
1958          
1959          /* Modify the slice configuration stored in schCb */
1960          if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceReCfgReq, schSliceReCfgRsp, count) != ROK)
1961          {
1962             DU_LOG("\nERROR  -->  SCH : Failed to modify slice cfg of SchDb");
1963             return RFAILED;
1964          }
1965          SchSendSliceReCfgRspToMac(inst, schSliceReCfgRsp);
1966       }
1967    }
1968    else
1969    {
1970       DU_LOG("\nERROR  -->  SCH : Received SchSliceCfgReq is NULL");
1971    }
1972    return ROK;
1973 }
1974
1975 /**********************************************************************
1976   End of file
1977  **********************************************************************/