Optional parameters filling in Du to CU RRC Container
[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 "stdbool.h"
35 #include "envopt.h"        /* environment options */
36 #include "envdep.h"        /* environment dependent */
37 #include "envind.h"        /* environment independent */
38 #include "gen.h"           /* general layer */
39 #include "ssi.h"           /* system service interface */
40 #include "cm_tkns.h"       /* Common Token Defines */
41 #include "cm_llist.h"      /* Common Link List Defines */
42 #include "cm_hash.h"       /* Common Hash List Defines */
43 #include "cm_mblk.h"       /* common memory link list library */
44 #include "cm_lte.h"        /* Common LTE Defines */
45 #include "lrg.h"
46 #include "rgr.h"
47 #include "tfu.h"
48 #include "rg_sch_inf.h"
49 #include "rg_sch.h"
50 #include "gen.x"           /* general layer typedefs */
51 #include "ssi.x"           /* system services typedefs */
52 #include "cm5.x"           /* system services */
53 #include "cm_tkns.x"       /* Common Token Definitions */
54 #include "cm_llist.x"      /* Common Link List Definitions */
55 #include "cm_lib.x"        /* Common Library Definitions */
56 #include "cm_hash.x"       /* Common Hash List Definitions */
57 #include "cm_mblk.x"       /* common memory link list library */
58 #include "cm_lte.x"        /* Common LTE Defines */
59 #include "tfu.x"           /* TFU types */
60 #include "lrg.x"           /* layer management typedefs for MAC */
61 #include "rgr.x"           /* layer management typedefs for MAC */
62 #include "rg_sch_inf.x"         /* typedefs for Scheduler */
63 #include "du_app_mac_inf.h"
64 #include "mac_sch_interface.h"
65 #include "sch.h"
66 #include "sch_utils.h"
67 #include "du_log.h"
68 extern SchCb schCb[SCH_MAX_INST];
69 void SchFillCfmPst(Pst *reqPst,Pst *cfmPst,RgMngmt *cfm);
70 /* local defines */
71 SchCellCfgCfmFunc SchCellCfgCfmOpts[] = 
72 {
73         packSchCellCfgCfm,     /* LC */
74         MacProcSchCellCfgCfm,  /* TC */
75         packSchCellCfgCfm      /* LWLC */
76 };
77
78
79 /**
80  * @brief Task Initiation function. 
81  *
82  * @details
83  *
84  *     Function : schActvInit
85  *     
86  *     This function is supplied as one of parameters during MAC's 
87  *     task registration. MAC will invoke this function once, after
88  *     it creates and attaches this TAPA Task to a system task.
89  *     
90  *  @param[in]  Ent Entity, the entity ID of this task.     
91  *  @param[in]  Inst Inst, the instance ID of this task.
92  *  @param[in]  Region Region, the region ID registered for memory 
93  *              usage of this task.
94  *  @param[in]  Reason Reason.
95  *  @return  int
96  *      -# ROK
97  **/
98 int schActvInit
99 (
100 Ent    entity,            /* entity */
101 Inst   instId,             /* instance */
102 Region region,         /* region */
103 Reason reason          /* reason */
104 )
105 {
106    Inst inst = (instId  - SCH_INST_START);
107
108    /* Initialize the MAC TskInit structure to zero */
109    cmMemset ((uint8_t *)&schCb[inst], 0, sizeof(schCb));
110
111    /* Initialize the MAC TskInit with received values */
112    schCb[inst].schInit.ent = entity;
113    schCb[inst].schInit.inst = inst;
114    schCb[inst].schInit.region = region;
115    schCb[inst].schInit.pool = 0;
116    schCb[inst].schInit.reason = reason;
117    schCb[inst].schInit.cfgDone = FALSE;
118    schCb[inst].schInit.acnt = FALSE;
119    schCb[inst].schInit.usta = FALSE;
120    schCb[inst].schInit.trc = FALSE;
121    schCb[inst].schInit.procId = SFndProcId();
122
123    RETVALUE(ROK);
124 } /* schActvInit */
125
126 /**
127  * @brief Scheduler instance Configuration Handler. 
128  *
129  * @details
130  *
131  *     Function : SchInstCfg
132  *     
133  *     This function in called by HandleSchGenCfgReq(). It handles the
134  *     general configurations of the scheduler instance. Returns
135  *     reason for success/failure of this function.
136  *     
137  *  @param[in]  RgCfg *cfg, the Configuaration information 
138  *  @return  U16
139  *      -# LCM_REASON_NOT_APPL 
140  *      -# LCM_REASON_INVALID_MSGTYPE
141  *      -# LCM_REASON_MEM_NOAVAIL
142  **/
143 PUBLIC U16 SchInstCfg
144 (
145 RgCfg *cfg,            /* Configuaration information */
146 Inst  dInst
147 )
148 {
149    uint16_t ret = LCM_REASON_NOT_APPL;
150    Inst     inst = (dInst - SCH_INST_START);
151
152    printf("\nEntered SchInstCfg()");
153    /* Check if Instance Configuration is done already */
154    if (schCb[inst].schInit.cfgDone == TRUE)
155    {
156       RETVALUE(LCM_REASON_INVALID_MSGTYPE);
157    }
158    /* Update the Pst structure for LM interface */
159    cmMemcpy((U8 *)&schCb[inst].schInit.lmPst,
160             (U8 *)&cfg->s.schInstCfg.genCfg.lmPst,
161              sizeof(Pst));
162    
163    schCb[inst].schInit.inst = inst;
164    schCb[inst].schInit.lmPst.srcProcId = schCb[inst].schInit.procId;
165    schCb[inst].schInit.lmPst.srcEnt = schCb[inst].schInit.ent;
166    schCb[inst].schInit.lmPst.srcInst = schCb[inst].schInit.inst +
167    SCH_INST_START;
168    schCb[inst].schInit.lmPst.event = EVTNONE;
169
170    schCb[inst].schInit.region = cfg->s.schInstCfg.genCfg.mem.region;
171    schCb[inst].schInit.pool = cfg->s.schInstCfg.genCfg.mem.pool;
172    schCb[inst].genCfg.tmrRes = cfg->s.schInstCfg.genCfg.tmrRes;
173 #ifdef LTE_ADV
174    schCb[inst].genCfg.forceCntrlSrbBoOnPCel =  cfg->s.schInstCfg.genCfg.forceCntrlSrbBoOnPCel;
175    schCb[inst].genCfg.isSCellActDeactAlgoEnable =  cfg->s.schInstCfg.genCfg.isSCellActDeactAlgoEnable;
176 #endif
177    schCb[inst].genCfg.startCellId    = cfg->s.schInstCfg.genCfg.startCellId;
178 #if 0
179    /* Initialzie the timer queue */   
180    cmMemset((U8 *)&schCb[inst].tmrTq, 0, sizeof(CmTqType)*RGSCH_TQ_SIZE);
181    /* Initialize the timer control point */
182    cmMemset((U8 *)&schCb[inst].tmrTqCp, 0, sizeof(CmTqCp));
183    schCb[inst].tmrTqCp.tmrLen = RGSCH_TQ_SIZE;
184
185    /* SS_MT_TMR needs to be enabled as schActvTmr needs instance information */
186    /* Timer Registration request to SSI */
187    if (SRegTmrMt(schCb[inst].schInit.ent, dInst,
188       (S16)schCb[inst].genCfg.tmrRes, schActvTmr) != ROK)
189    {
190       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "SchInstCfg(): Failed to "
191              "register timer.");
192       RETVALUE(LCM_REASON_MEM_NOAVAIL);
193    }   
194 #endif               
195    /* Set Config done in TskInit */
196    schCb[inst].schInit.cfgDone = TRUE;
197    printf("\nScheduler gen config done");
198    
199    RETVALUE(ret);
200 }
201
202 /**
203  * @brief Layer Manager Configuration request handler. 
204  *
205  * @details
206  *
207  *     Function : HandleSchGenCfgReq
208  *     
209  *     This function handles the configuration
210  *     request received at scheduler instance from the Layer Manager.
211  *     -# Based on the cfg->hdr.elmId.elmnt value it invokes one of the
212  *        functions rgHdlGenCfg() or rgHdlSapCfg().
213  *     -# Invokes RgMiLrgSchCfgCfm() to send back the confirmation to the LM.
214  *     
215  *  @param[in]  Pst *pst, the post structure     
216  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
217  *  @return  S16
218  *      -# ROK
219  **/
220 int HandleSchGenCfgReq
221 (
222 Pst      *pst,    /* post structure  */
223 RgMngmt  *cfg     /* config structure  */
224 )
225 {
226    uint16_t       ret = LCM_PRIM_OK;
227    uint16_t       reason = LCM_REASON_NOT_APPL;
228    RgMngmt   cfm;
229    Pst       cfmPst;
230
231    if(pst->dstInst < SCH_INST_START)
232    {
233       DU_LOG("\nInvalid inst ID");
234       DU_LOG("\nHandleSchGenCfgReq(): "
235                 "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); 
236       RETVALUE(ROK);
237    }
238    printf("\nReceived scheduler gen config");
239    /* Fill the post structure for sending the confirmation */
240         memset(&cfmPst, 0 , sizeof(Pst));
241    SchFillCfmPst(pst, &cfmPst, cfg);
242
243    cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
244
245 #ifdef LMINT3
246    cfm.hdr.transId =
247       cfg->hdr.transId;
248 #endif
249
250    cfm.hdr.elmId.elmnt = cfg->hdr.elmId.elmnt;
251    switch(cfg->hdr.elmId.elmnt)
252    {
253       case STSCHINST:
254          reason = SchInstCfg(&cfg->t.cfg,pst->dstInst );
255          break;
256       default:
257          ret = LCM_PRIM_NOK;
258          reason = LCM_REASON_INVALID_ELMNT;
259          DU_LOG("\nInvalid Elmnt=%d", cfg->hdr.elmId.elmnt);
260          break;
261    }
262
263    if (reason != LCM_REASON_NOT_APPL)
264    {
265       ret = LCM_PRIM_NOK;
266    }
267
268    cfm.cfm.status = ret;
269    cfm.cfm.reason = reason;
270
271    SchSendCfgCfm(&cfmPst, &cfm);
272    /*   SPutSBuf(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */
273    
274    RETVALUE(ROK);
275 }/*-- HandleSchGenCfgReq --*/
276
277 /**
278  * @brief slot indication from MAC to SCH.
279  *
280  * @details
281  *
282  *     Function : macSchSlotInd 
283  *      
284  *      This API is invoked by PHY to indicate slot indication to Scheduler for
285  *      a cell.
286  *           
287  *  @param[in]  Pst            *pst
288  *  @param[in]  SlotIndInfo    *slotInd
289  *  @return  S16
290  *      -# ROK 
291  *      -# RFAILED 
292  **/
293 int macSchSlotInd 
294 (
295 Pst                 *pst, 
296 SlotIndInfo         *slotInd
297 )
298 {
299    Inst  inst = pst->dstInst-SCH_INST_START;
300
301    /* Now call the TOM (Tfu ownership module) primitive to process further */
302    schProcessSlotInd(slotInd, inst);
303
304    RETVALUE(ROK);
305 }  /* macSchSlotInd */
306
307 /*******************************************************************
308  *
309  * @brief Processes Rach indication from MAC 
310  *
311  * @details
312  *
313  *    Function : macSchRachInd
314  *
315  *    Functionality:
316  *      Processes Rach indication from MAC
317  *
318  * @params[in] 
319  * @return ROK     - success
320  *         RFAILED - failure
321  *
322  * ****************************************************************/
323 int macSchRachInd(Pst *pst, RachIndInfo *rachInd)
324 {
325    Inst  inst = pst->dstInst-SCH_INST_START;
326    DU_LOG("\nSCH : Received Rach indication");
327    schProcessRachInd(rachInd, inst);
328    return ROK;
329 }
330
331 /*******************************************************************
332  *
333  * @brief Processes CRC indication from MAC 
334  *
335  * @details
336  *
337  *    Function : macSchCrcInd
338  *
339  *    Functionality:
340  *      Processes CRC indication from MAC
341  *
342  * @params[in] Post structure
343  *             Crc Indication
344  * @return ROK     - success
345  *         RFAILED - failure
346  *
347  * ****************************************************************/
348 int macSchCrcInd(Pst *pst, CrcIndInfo *crcInd)
349 {
350    switch(crcInd->crcInd[0])
351         {
352       case CRC_FAILED:
353          DU_LOG("\nSCH : Received CRC indication. CRC Status [FAILURE]");
354                         break;
355       case CRC_PASSED:
356          DU_LOG("\nSCH : Received CRC indication. CRC Status [PASS]");
357                         break;
358            default:
359                         DU_LOG("\nSCH : Invalid CRC state %d", crcInd->crcInd[0]);
360                         return RFAILED;
361         }
362    return ROK;
363 }
364
365
366 /**
367  * @brief inti cellCb based on cellCfg
368  *
369  * @details
370  *
371  *     Function : InitSchCellCb 
372  *      
373  *      This API is invoked after receiving schCellCfg
374  *           
375  *  @param[in]  schCellCb *cell
376  *  @param[in]  SchCellCfg *schCellCfg
377  *  @return  int
378  *      -# ROK 
379  *      -# RFAILED 
380  **/
381 int InitSchCellCb(Inst inst, SchCellCfg *schCellCfg)
382 {
383    SchCellCb *cell;
384    SCH_ALLOC(cell, sizeof(SchCellCb));
385         if(!cell)
386         {
387       DU_LOG("\nMemory allocation failed in InitSchCellCb");
388                 return RFAILED;
389         }
390
391         cell->cellId = schCellCfg->cellId; 
392         cell->instIdx = inst;
393         switch(schCellCfg->ssbSchCfg.scsCommon)
394         {
395            case SCH_SCS_15KHZ:
396                 {
397                         cell->numSlots = SCH_NUM_SLOTS;
398                 }
399                 break;
400                 default:
401                    DU_LOG("\nSCS %d not supported", schCellCfg->ssbSchCfg.scsCommon);
402         }
403   
404    for(uint8_t idx=0; idx<SCH_NUM_SLOTS; idx++)
405         {
406                 SchDlAlloc *schDlAlloc;
407                 SchUlAlloc *schUlAlloc;
408
409       /* DL Alloc */
410                 SCH_ALLOC(schDlAlloc, sizeof(SchDlAlloc));
411                 if(!schDlAlloc)
412                 {
413                         DU_LOG("\nMemory allocation failed in InitSchCellCb");
414                         return RFAILED;
415                 }
416
417       /* UL Alloc */
418                 SCH_ALLOC(schUlAlloc, sizeof(SchUlAlloc));
419                 if(!schUlAlloc)
420                 {
421                         DU_LOG("\nMemory allocation failed in InitSchCellCb");
422                         return RFAILED;
423                 }
424
425       schDlAlloc->totalPrb = schUlAlloc->totalPrb = MAX_NUM_RB;
426
427                 for(uint8_t itr=0; itr<SCH_SYMBOL_PER_SLOT; itr++)
428                 {
429                         schDlAlloc->assignedPrb[itr] = 0;
430                         schUlAlloc->assignedPrb[itr] = 0;
431                 }
432                 schUlAlloc->schPuschInfo = NULLP;
433
434                 for(uint8_t itr=0; itr<MAX_SSB_IDX; itr++)
435                 {
436                         memset(&schDlAlloc->ssbInfo[itr], 0, sizeof(SsbInfo));
437                 }
438
439                 cell->dlAlloc[idx] = schDlAlloc;
440                 cell->ulAlloc[idx] = schUlAlloc;
441
442         }
443         schCb[inst].cells[inst] = cell;
444
445    DU_LOG("\nCell init completed for cellId:%d", cell->cellId);
446
447    return ROK;   
448 }
449
450 void fillSchSib1Cfg(
451 Inst         schInst,
452 SchSib1Cfg   *sib1SchCfg,
453 uint16_t     pci,
454 uint8_t      offsetPointA
455 )
456 {
457    uint8_t coreset0Idx = 0;
458    uint8_t searchSpace0Idx = 0;
459    //uint8_t ssbMuxPattern = 0;
460    uint8_t numRbs = 0;
461    uint8_t numSymbols = 0;
462    uint8_t offset = 0;
463    uint8_t oValue = 0;
464    //uint8_t numSearchSpacePerSlot = 0;
465    uint8_t mValue = 0;
466    uint8_t firstSymbol = 0; /* need to calculate using formula mentioned in 38.213 */
467    uint8_t slotIndex = 0;
468    uint8_t FreqDomainResource[6] = {0};
469
470    PdcchCfg *pdcch = &(sib1SchCfg->sib1PdcchCfg);
471    PdschCfg *pdsch = &(sib1SchCfg->sib1PdschCfg);
472
473    coreset0Idx     = sib1SchCfg->coresetZeroIndex;
474    searchSpace0Idx = sib1SchCfg->searchSpaceZeroIndex;
475
476    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
477    //ssbMuxPattern = coresetIdxTable[coreset0Idx][0];
478    numRbs        = coresetIdxTable[coreset0Idx][1];
479    numSymbols    = coresetIdxTable[coreset0Idx][2];
480    offset        = coresetIdxTable[coreset0Idx][3];
481
482    /* derive the search space params from table 13-11 spec 38.213 */
483    oValue                = searchSpaceIdxTable[searchSpace0Idx][0];
484    //numSearchSpacePerSlot = searchSpaceIdxTable[searchSpace0Idx][1];
485    mValue                = searchSpaceIdxTable[searchSpace0Idx][2];
486    firstSymbol           = searchSpaceIdxTable[searchSpace0Idx][3];
487
488    /* calculate the n0, need to add the formulae, as of now the value is 0 
489     * Need to add the even and odd values of i during configuration 
490     * [(O . 2^u + i . M )  ] mod numSlotsPerSubframe 
491     * assuming u = 0, i = 0, numSlotsPerSubframe = 10
492     * Also, from this configuration, coreset0 is only on even subframe */
493    slotIndex = ((oValue * 1) + (0 * mValue)) % 10; 
494    sib1SchCfg->n0 = slotIndex;
495  
496    /* calculate the PRBs */
497    calculatePRB( ((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource);
498
499    /* fill the PDCCH PDU */
500    pdcch->pdcchBwpCfg.BWPSize = MAX_NUM_RB; /* whole of BW */
501    pdcch->pdcchBwpCfg.BWPStart = 0;
502    pdcch->pdcchBwpCfg.subcarrierSpacing = 0;         /* 15Khz */
503    pdcch->pdcchBwpCfg.cyclicPrefix = 0;              /* normal */
504    pdcch->coreset0Cfg.coreSet0Size = numRbs;
505    pdcch->coreset0Cfg.startSymbolIndex = firstSymbol;
506    pdcch->coreset0Cfg.durationSymbols = numSymbols;
507    memcpy(pdcch->coreset0Cfg.freqDomainResource,FreqDomainResource,6);
508    pdcch->coreset0Cfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
509    pdcch->coreset0Cfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
510    pdcch->coreset0Cfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
511    pdcch->coreset0Cfg.coreSetType = 0;
512    pdcch->coreset0Cfg.shiftIndex = pci;
513    pdcch->coreset0Cfg.precoderGranularity = 0; /* sameAsRegBundle */
514    pdcch->numDlDci = 1;
515    pdcch->dci.rnti = SI_RNTI;
516    pdcch->dci.scramblingId = pci;
517    pdcch->dci.scramblingRnti = 0;
518    pdcch->dci.cceIndex = 0;
519    pdcch->dci.aggregLevel = 4;
520    pdcch->dci.beamPdcchInfo.numPrgs = 1;
521    pdcch->dci.beamPdcchInfo.prgSize = 1;
522    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
523    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
524    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
525    pdcch->dci.txPdcchPower.powerValue = 0;
526    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
527         /* Storing pdschCfg pointer here. Required to access pdsch config while
528         fillig up pdcch pdu */
529    pdcch->dci.pdschCfg = pdsch; 
530
531    /* fill the PDSCH PDU */
532         uint8_t cwCount = 0;
533    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
534    pdsch->rnti = 0xFFFF; /* SI-RNTI */
535    pdsch->pduIndex = 0;
536    pdsch->pdschBwpCfg.BWPSize = MAX_NUM_RB; /* whole of BW */
537    pdsch->pdschBwpCfg.BWPStart = 0;
538    pdsch->numCodewords = 1;
539         for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
540         {
541       pdsch->codeword[cwCount].targetCodeRate = 308;
542       pdsch->codeword[cwCount].qamModOrder = 2;
543       pdsch->codeword[cwCount].mcsIndex = sib1SchCfg->sib1Mcs;
544       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
545       pdsch->codeword[cwCount].rvIndex = 0;
546       pdsch->codeword[cwCount].tbSize = 768/8; /* 38.214: Table 5.1.3.2-1,
547                    devided by 8 to get the value in bytes */
548    }
549    pdsch->dataScramblingId = pci;
550    pdsch->numLayers = 1;
551    pdsch->transmissionScheme = 0;
552    pdsch->refPoint = 0;
553    pdsch->dmrs.dlDmrsSymbPos = 2;
554    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
555    pdsch->dmrs.dlDmrsScramblingId = pci;
556    pdsch->dmrs.scid = 0;
557    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
558    pdsch->dmrs.dmrsPorts = 0;
559    pdsch->freqAlloc.resourceAlloc = 1; /* RAT type-1 RIV format */
560    pdsch->freqAlloc.rbStart = offset + SCH_SSB_PRB_DURATION; /* the RB numbering starts from coreset0, and PDSCH is always above SSB */ 
561         /* formula used for calculation of rbSize, 38.213 section 5.1.3.2 *
562          * Ninfo = Nre . R . Qm . v                                       *
563          * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh                       *
564          * Nre = min(156,Nre') . nPrb                                     */
565    pdsch->freqAlloc.rbSize = 10; /* This value is calculated from above formulae */
566    pdsch->freqAlloc.vrbPrbMapping = 0; /* non-interleaved */
567    pdsch->timeAlloc.rowIndex = 1;
568    pdsch->timeAlloc.startSymbolIndex = 2; /* spec-38.214, Table 5.1.2.1-1 */
569    pdsch->timeAlloc.numSymbols = 12;
570    pdsch->beamPdschInfo.numPrgs = 1;
571    pdsch->beamPdschInfo.prgSize = 1;
572    pdsch->beamPdschInfo.digBfInterfaces = 0;
573    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
574    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
575    pdsch->txPdschPower.powerControlOffset = 0;
576    pdsch->txPdschPower.powerControlOffsetSS = 0;
577
578 }
579
580 /**
581  * @brief cell config from MAC to SCH.
582  *
583  * @details
584  *
585  *     Function : macSchCellCfgReq
586  *      
587  *      This API is invoked by MAC to send cell config to SCH
588  *           
589  *  @param[in]  Pst            *pst
590  *  @param[in]  SchCellCfg     *schCellCfg
591  *  @return  int
592  *      -# ROK 
593  *      -# RFAILED 
594  **/
595 int SchHdlCellCfgReq
596 (
597 Pst                 *pst, 
598 SchCellCfg          *schCellCfg
599 )
600 {
601    int ret = ROK;
602    SchCellCb *cellCb;
603         SchCellCfgCfm schCellCfgCfm;
604         Pst rspPst;
605         Inst inst = pst->dstInst-1; 
606
607         InitSchCellCb(inst, schCellCfg);
608         cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst
609    cellCb->macInst = pst->srcInst;
610
611    /* derive the SIB1 config parameters */
612         fillSchSib1Cfg(
613            inst,
614            &(schCellCfg->sib1SchCfg),
615                 schCellCfg->phyCellId,
616                 schCellCfg->ssbSchCfg.ssbOffsetPointA);
617    memcpy(&cellCb->cellCfg, schCellCfg, sizeof(SchCellCfg));
618
619    memset(&rspPst, 0, sizeof(Pst));
620    SCH_FILL_RSP_PST(rspPst, inst);
621         rspPst.event = EVENT_SCH_CELL_CFG_CFM;
622         schCellCfgCfm.rsp = RSP_OK;
623   
624    ret = (*SchCellCfgCfmOpts[rspPst.selector])(&rspPst, &schCellCfgCfm);
625
626    return ret;
627
628 }
629
630 /*******************************************************************
631  *
632  * @brief Processes DL RLC BO info from MAC
633  *
634  * @details
635  *
636  *    Function : macSchDlRlcBoInfo
637  *
638  *    Functionality:
639  *       Processes DL RLC BO info from MAC
640  *
641  * @params[in] 
642  * @return ROK     - success
643  *         RFAILED - failure
644  *
645  * ****************************************************************/
646 uint8_t macSchDlRlcBoInfo(Pst *pst, DlRlcBOInfo *dlBoInfo)
647 {
648    uint16_t  lcIdx;
649    Inst  inst = pst->dstInst-SCH_INST_START;
650    DU_LOG("\nSCH : Received RLC BO Status indication");
651
652    SchCellCb *cell = schCb[inst].cells[inst];
653    SchDlAlloc *dlAlloc = \
654       cell->dlAlloc[(cell->slotInfo.slot + SCHED_DELTA) % SCH_NUM_SLOTS]; 
655   
656    for(lcIdx = 0; lcIdx < dlBoInfo->numLc; lcIdx++)
657         {
658            if(dlBoInfo->boInfo[lcIdx].lcId == CCCH_LCID)
659                 {
660               SCH_ALLOC(dlAlloc->msg4Info, sizeof(Msg4Info));
661               if(!dlAlloc->msg4Info)
662               {
663                  DU_LOG("\nSCH : Memory allocation failed for msg4Info");
664                       dlAlloc = NULL;
665                       return RFAILED;
666               }
667          dlAlloc->msg4Info->crnti = dlBoInfo->crnti;
668                         dlAlloc->msg4Info->ndi = 1;
669                         dlAlloc->msg4Info->harqProcNum = 0;
670                         dlAlloc->msg4Info->dlAssignIdx = 0;
671                         dlAlloc->msg4Info->pucchTpc = 0;
672                         dlAlloc->msg4Info->pucchResInd = 0;
673                         dlAlloc->msg4Info->harqFeedbackInd = 0;
674                         dlAlloc->msg4Info->dciFormatId = 1;
675            }
676    }
677
678    return ROK;
679 }
680
681 /**********************************************************************
682          End of file
683 **********************************************************************/