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