dac40baef26771251e3a401cd66c17ffe9eac15a
[o-du/l2.git] / src / 5gnrmac / mac_cfg_hdl.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 /* This file stores handler for MAC and SCH configuration requests */
19 /* header include files (.h) */
20 #include "common_def.h"
21 #include "lrg.h"
22 #include "lrg.x"
23 #include "du_app_mac_inf.h"
24 #include "mac_sch_interface.h"
25 #include "lwr_mac_upr_inf.h"
26 #include "mac.h"
27 #include "rlc_mac_inf.h"
28 #include "mac_upr_inf_api.h"
29 #include "lwr_mac.h"
30 #include "lwr_mac_fsm.h"
31 #include "mac_utils.h"
32 #include "lwr_mac_phy.h"
33
34 uint8_t ssbPeriodicity[6] = {5, 10, 20, 40, 80, 160};
35
36 uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg  *macCellCfg);
37
38 packMacCellCfgConfirm packMacCellCfmOpts[] =
39 {
40    packMacCellCfgCfm,      /* packing for loosely coupled */
41    duHandleMacCellCfgCfm,      /* packing for tightly coupled */
42    packMacCellCfgCfm,    /* packing for light weight loosly coupled */
43 };
44
45 MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
46 {
47    packDuMacCellDeleteRsp,   /* packing for loosely coupled */
48    DuProcMacCellDeleteRsp,   /* packing for tightly coupled */
49    packDuMacCellDeleteRsp   /* packing for light weight loosly coupled */
50 };
51
52 MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] =
53 {
54    packDuMacSliceCfgRsp,   /* packing for loosely coupled */
55    DuProcMacSliceCfgRsp,   /* packing for tightly coupled */
56    packDuMacSliceCfgRsp   /* packing for light weight loosly coupled */
57 };
58
59 MacDuSliceRecfgRspFunc macDuSliceRecfgRspOpts[] =
60 {
61    packDuMacSliceRecfgRsp,   /* packing for loosely coupled */
62    DuProcMacSliceRecfgRsp,   /* packing for tightly coupled */
63    packDuMacSliceRecfgRsp    /* packing for light weight loosly coupled */
64 };
65
66 MacDuStatsRspFunc macDuStatsRspOpts[] =
67 {
68    packDuMacStatsRsp,   /* packing for loosely coupled */
69    DuProcMacStatsRsp,   /* packing for tightly coupled */
70    packDuMacStatsRsp   /* packing for light weight loosly coupled */
71 };
72
73 MacDuStatsDeleteRspFunc macDuStatsDeleteRspOpts[] =
74 {
75    packDuMacStatsDeleteRsp,   /* packing for loosely coupled */
76    DuProcMacStatsDeleteRsp,   /* packing for tightly coupled */
77    packDuMacStatsDeleteRsp   /* packing for light weight loosly coupled */
78 };
79
80 MacDuStatsModificationRspFunc macDuStatsModificationRspOpts[] =
81 {
82    packDuMacStatsModificationRsp,   /* packing for loosely coupled */
83    DuProcMacStatsModificationRsp,   /* packing for tightly coupled */
84    packDuMacStatsModificationRsp   /* packing for light weight loosly coupled */
85 };
86
87 /**
88  * @brief Layer Manager  Configuration request handler for Scheduler
89  *
90  * @details
91  *
92  *     Function : MacSchGenCfgReq
93  *
94  *     This function receives general configurations for Scheduler
95  *     from DU APP and forwards to Scheduler.
96  *
97  *  @param[in]  Pst *pst, the post structure
98  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
99  *  @return 
100  *      -# ROK
101  **/
102 uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
103 {
104    Pst schPst;
105
106    DU_LOG("\nINFO  -->  MAC : Received Scheduler gen config at MAC");
107    memset(&schPst, 0, sizeof(Pst));
108    FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG);
109    
110    return(SchMessageRouter(&schPst, (void *)cfg));
111 }
112
113 /**
114  * @brief Layer Manager Configuration response from Scheduler
115  *
116  * @details
117  *
118  *     Function : SchSendCfgCfm
119  *
120  *     This function sends general configurations response from
121  *     Scheduler to DU APP.
122  *
123  *  @param[in]  Pst *pst, the post structure
124  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
125  *  @return 
126  *      -# ROK
127  **/
128 uint8_t SchSendCfgCfm(Pst *pst, RgMngmt  *cfm)
129 {
130    DU_LOG("\nDEBUG  -->  MAC : Sending Scheduler config confirm to DU APP");
131    pst->dstEnt = ENTDUAPP;
132    pst->dstInst = 0;
133    pst->srcInst = 0;
134    pst->selector = ODU_SELECTOR_LC;
135    RgMiLrgSchCfgCfm(pst, cfm);
136
137    return ROK;
138 }
139
140 /**
141  * @brief Layer Manager Configuration request handler.
142  *
143  * @details
144  *
145  *     Function : MacProcCellCfgReq
146  *
147  *     This function handles the gNB and cell configuration
148  *     request received from DU APP.
149  *     This API unapcks and forwards the config towards SCH
150  *
151  *  @param[in]  Pst           *pst
152  *  @param[in]  MacCellCfg    *macCellCfg
153  *  @return  
154  *      -# ROK
155  **/
156 uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
157 {
158    Pst cfmPst;
159    uint16_t cellIdx, scsInKhz = 0;
160    uint8_t ret = ROK, plmnIdx = 0,sliceIdx = 0;
161    MacCellCb     *macCellCb;
162
163    memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
164
165    MAC_ALLOC(macCellCb, sizeof(MacCellCb));
166    if(macCellCb == NULLP)
167    {
168       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of macCellCfg\n");
169       return RFAILED;
170    }
171    memset(macCellCb, 0, sizeof(MacCellCb));
172
173    GET_CELL_IDX(macCellCfg->cellId, cellIdx);
174    macCb.macCell[cellIdx] = macCellCb;
175    macCb.macCell[cellIdx]->cellId = macCellCfg->cellId;
176    scsInKhz = convertScsEnumValToScsVal(macCellCfg->cellCfg.subCarrSpacing);
177    
178    /*Ref : 3GPP 38.211 Table 4.2-1: SCS = (2 ^ numerology * 15kHz)*/
179    macCb.macCell[cellIdx]->numerology = log2(scsInKhz/BASE_SCS);
180    macCb.macCell[cellIdx]->numOfSlots = 10 * (1 << (macCb.macCell[cellIdx]->numerology));
181    memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg));
182
183    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, \
184          macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen);
185    if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu == NULLP)
186    {
187       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
188       return RFAILED;
189    }
190    memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, macCellCfg->cellCfg.sib1Cfg.sib1Pdu, \
191          macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen);
192
193    for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++)
194    {
195       macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices = macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices;
196       MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai, macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices\
197             * sizeof(Snssai*));
198       if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai == NULLP)
199       {
200          DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
201          return RFAILED;
202       }
203
204       if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai)
205       {
206          for(sliceIdx=0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++)
207          {
208             if(macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
209             {
210                MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
211                if(!macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
212                {
213                   DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
214                   return RFAILED;
215                }
216                memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx],\
217                      sizeof(Snssai));
218             }
219          }
220       }
221    }
222    /* Send cell cfg to scheduler */
223    ret = MacSchCellCfgReq(pst, macCellCfg);
224    if(ret != ROK)
225    {
226       MacCellCfgCfm macCellCfgCfm;
227       macCellCfgCfm.rsp = RSP_NOK;
228       macCellCfgCfm.cellId = macCellCfg->cellId;
229       /* Fill Pst */
230       FILL_PST_MAC_TO_DUAPP(cfmPst, EVENT_MAC_CELL_CONFIG_CFM);
231       cfmPst.selector  = ODU_SELECTOR_LC;
232
233       ret = (*packMacCellCfmOpts[cfmPst.selector])(&cfmPst,&macCellCfgCfm);
234    }
235    else
236    {
237       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
238    }
239    return ret;
240 } /* end of MacProcCellCfgReq */
241
242 /**
243  * @brief Layer Manager Configuration request handler.
244  *
245  * @details
246  *
247  *     Function : MacSchCellCfgReq
248  *
249  *     This function sends cell configuration to SCH
250  *
251  *  @param[in]  Pst           *pst
252  *  @param[in]  MacCellCfg    *macCellCfg
253  *  @return  
254  *      -# ROK
255  **/
256 uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
257 {
258    SchCellCfg schCellCfg;
259    Pst        cfgPst;
260    uint8_t    ssbMaskIdx = 0, rsrcListIdx = 0, sliceIdx=0, plmnIdx = 0;
261
262    memset(&cfgPst, 0, sizeof(Pst));
263    memset(&schCellCfg, 0, sizeof(SchCellCfg));
264    schCellCfg.cellId = macCellCfg->cellId;
265    schCellCfg.phyCellId = macCellCfg->cellCfg.phyCellId;
266
267    for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++)
268    {
269       schCellCfg.plmnInfoList[plmnIdx].plmn = macCellCfg->cellCfg.plmnInfoList[plmnIdx].plmn;
270       if(macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai) 
271       {
272          schCellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices = macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices;
273          MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai, schCellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices * sizeof(Snssai*));
274          if(!schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai)
275          {
276             DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
277             return RFAILED;
278          }
279          for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++)
280          {
281             if(macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
282             {
283                MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
284                if(!schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx])
285                {
286                   DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
287                   return RFAILED;
288                }
289                memcpy(schCellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx],  sizeof(Snssai));
290             }
291          }
292       }
293    }
294
295    schCellCfg.dupMode = macCellCfg->cellCfg.dupType;
296    schCellCfg.dlBandwidth = macCellCfg->carrCfg.dlBw;
297    schCellCfg.ulBandwidth = macCellCfg->carrCfg.ulBw;
298
299    schCellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
300    schCellCfg.dlCfgCommon.schFreqInfoDlSib.schSpcCarrier[0].subCarrierSpacing = macCellCfg->ssbCfg.scsCmn;
301
302    /* fill initial DL BWP */
303    schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialDlBwp.bwp.firstPrb;
304    schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialDlBwp.bwp.numPrb;
305    schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.scs = macCellCfg->cellCfg.initialDlBwp.bwp.scs;
306    schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialDlBwp.bwp.cyclicPrefix;
307    
308    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId =
309       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId;
310    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId =
311       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.coresetId;
312    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot =
313       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot;
314    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration =
315       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.duration;
316    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol =
317       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol;
318    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 =
319       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1;
320    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 =
321       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2;
322    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 =
323       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4;
324    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 =
325       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8;
326    schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 =
327       macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16;
328    
329    schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->cellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc;
330    for(rsrcListIdx = 0; rsrcListIdx<macCellCfg->cellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++)
331    {
332       schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = 
333          macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0;
334       schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
335          macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
336       schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
337          macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
338       schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol =
339          macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol;
340    }
341
342    /* fill SIB1 scheduler parameters */
343    schCellCfg.dlCfgCommon.schPcchCfg.numPO  =  macCellCfg->cellCfg.sib1Cfg.pagingCfg.numPO;
344    schCellCfg.dlCfgCommon.schPcchCfg.poPresent = macCellCfg->cellCfg.sib1Cfg.pagingCfg.poPresent;
345    if(schCellCfg.dlCfgCommon.schPcchCfg.poPresent)
346    {
347       memcpy(schCellCfg.dlCfgCommon.schPcchCfg.pagingOcc, macCellCfg->cellCfg.sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF);
348    }
349
350    /* fill initial UL BWP */
351    schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb;
352    schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb;
353    schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.scs = macCellCfg->cellCfg.initialUlBwp.bwp.scs;
354    schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix;
355    /* fill RACH config params */
356    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.prachCfgIdx   = macCellCfg->prachCfg.prachCfgIdx;
357    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1Fdm       = macCellCfg->prachCfg.msg1Fdm;
358    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart = macCellCfg->prachCfg.msg1FreqStart;
359    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.zeroCorrZoneCfg = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; 
360    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.raRspWindow = macCellCfg->prachCfg.raRspWindow;
361
362    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble;
363    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.ssbPerRach    = macCellCfg->prachCfg.ssbPerRach;
364    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb;
365    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.raContResTmr = macCellCfg->prachCfg.raContResTmr;
366    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb;
367    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqIdx    = macCellCfg->prachCfg.fdm[0].rootSeqIdx;
368    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.numRootSeq    = macCellCfg->prachCfg.fdm[0].numRootSeq;
369    schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.msg1SubcSpacing = \
370                                             macCellCfg->prachCfg.prachSubcSpacing;
371
372    schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchResourceCommon = \
373                                                                 macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchResourceCommon;
374    schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchGroupHopping = \
375                                                                 macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchGroupHopping;
376    schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \
377                                                                 macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc;
378    for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++)
379    {
380       schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = 
381          macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2;
382       schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
383          macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
384       schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
385          macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
386       schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength =
387          macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength;
388    }
389
390 #ifdef NR_TDD
391    memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
392 #endif
393
394    /* fill ssb scheduler parameters */
395    for(ssbMaskIdx=0; ssbMaskIdx<SSB_MASK_SIZE; ssbMaskIdx++)
396    {
397       schCellCfg.ssbPosInBurst[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx];
398    }
399    schCellCfg.ssbPeriod    = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
400    schCellCfg.ssbFrequency = macCellCfg->cellCfg.ssbFreq;
401    schCellCfg.dmrsTypeAPos = macCellCfg->ssbCfg.dmrsTypeAPos;
402    schCellCfg.ssbScs       = macCellCfg->cellCfg.subCarrSpacing;
403    schCellCfg.pdcchCfgSib1.coresetZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.coresetZeroIndex;
404    schCellCfg.pdcchCfgSib1.searchSpaceZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.searchSpaceZeroIndex;
405    schCellCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
406    schCellCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
407    schCellCfg.sib1PduLen = macCellCfg->cellCfg.sib1Cfg.sib1PduLen;
408    
409    FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG);
410
411    return(SchMessageRouter(&cfgPst, (void *)&schCellCfg));
412 } /* end of MacSchCellCfgReq */
413
414
415 /*******************************************************************
416  *
417  * @brief Sends Cell config confirm to DU APP
418  *
419  * @details
420  *
421  *    Function : MacSendCellCfgCfm
422  *
423  *    Functionality:
424  *      Sends Cell config confirm to DU APP
425  *
426  * @params[in] Response status
427  * @return void
428  *
429  * ****************************************************************/
430 void MacSendCellCfgCfm(uint16_t cellId, uint8_t response)
431 {
432    Pst pst;
433    uint16_t   cellIdx;
434    MacCellCfgCfm macCellCfgCfm;
435
436    memset(&pst, 0, sizeof(Pst));
437
438    GET_CELL_IDX(cellId, cellIdx);
439    macCellCfgCfm.cellId = macCb.macCell[cellIdx]->macCellCfg.cellId;
440    macCellCfgCfm.rsp = response;
441
442    /* Fill Pst */
443    FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_CELL_CONFIG_CFM);
444    pst.selector  = ODU_SELECTOR_LC;
445
446    (*packMacCellCfmOpts[pst.selector])(&pst,&macCellCfgCfm);
447 }
448
449
450 /**
451  * @brief Layer Manager Configuration response handler.
452  *
453  * @details
454  *
455  *     Function : MacProcSchCellCfgCfm
456  *
457  *     This function processes cell configuration to SCH
458  *
459  *  @param[in]  Pst           *pst
460  *  @param[in]  SchCellCfgCfm *schCellCfgCfm
461  *  @return  int
462  *      -# ROK
463  **/
464 uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm)
465 {
466    uint16_t *cellId = NULLP;
467
468 #ifdef CALL_FLOW_DEBUG_LOG
469    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
470 #endif
471
472    if(schCellCfgCfm->rsp == RSP_OK)
473    {
474       cellId = &schCellCfgCfm->cellId;
475 #ifdef INTEL_TIMER_MODE
476       sendToLowerMac(UL_IQ_SAMPLE, 0, (void *)cellId);
477 #else
478       sendToLowerMac(CONFIG_REQUEST, 0, (void *)cellId);
479 #endif
480    }
481    else
482    {
483       MacSendCellCfgCfm(schCellCfgCfm->cellId, RSP_NOK);
484    }
485    return ROK;
486 }
487
488 /*******************************************************************
489  *
490  * @brief MAC handler for config response from PHY
491  *
492  * @details
493  *
494  *    Function : fapiMacConfigRsp
495  *
496  *    Functionality:
497  *     Processes config response from PHY and sends cell config
498  *     confirm to DU APP
499  *
500  * @params[in]
501  * @return void
502  *
503  * ****************************************************************/
504 void fapiMacConfigRsp(uint16_t cellId)
505 {
506    /* TODO : Processing of config response from PHY */
507
508    /* Send cell config cfm to DU APP */
509    MacSendCellCfgCfm(cellId, RSP_OK);
510 }
511
512 /*******************************************************************
513  *
514  * @brief Fill and Send Cell Delete response from MAC to DU APP
515  *
516  * @details
517  *
518  *    Function : MacSendCellDeleteRsp
519  *
520  *    Functionality: Fill and Send Cell Delete response from MAC to DUAPP
521  *
522  * @params[in] MAC Cell delete result
523  *             SCH Cell delete response
524  * @return ROK     - success
525  *         RFAILED - failure
526  *
527  * ****************************************************************/
528 uint8_t MacSendCellDeleteRsp(CauseOfResult  status, uint8_t cellId)
529 {
530    MacCellDeleteRsp *deleteRsp=NULLP;
531    Pst            rspPst;
532
533    MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
534    if(!deleteRsp)
535    {
536       DU_LOG("\nERROR  -->  MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
537       return RFAILED;
538    }
539
540    /* Filling CELL delete response */
541    
542    memset(deleteRsp, 0, sizeof(MacCellDeleteRsp));
543    deleteRsp->cellId = cellId;
544    deleteRsp->status = status;
545
546    /* Fill Post structure and send CELL delete response*/
547    memset(&rspPst, 0, sizeof(Pst));
548    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
549    return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
550 }
551
552 /*******************************************************************
553  *
554  * @brief  Processes CELL delete response from scheduler
555  *
556  * @details
557  *
558  *    Function : MacProcSchCellDeleteRsp
559  *
560  *    Functionality:
561  *      Processes CELL delete from scheduler
562  *
563  * @params[in] Pst : Post structure
564  *             schCellDelRsp : Scheduler CELL delete respons
565  * @return ROK     - success
566  *         RFAILED - failure
567  *
568  * * ****************************************************************/
569 uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
570 {
571    uint8_t  ret = ROK, sliceIdx = 0, plmnIdx = 0;
572    uint16_t cellIdx=0;
573    CauseOfResult  cause;
574
575 #ifdef CALL_FLOW_DEBUG_LOG
576    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
577 #endif  
578
579    if(schCellDelRsp)
580    {
581       if(schCellDelRsp->rsp == RSP_OK)
582       {
583          DU_LOG("\nINFO   -->  MAC : SCH CELL Delete response for cellId[%d] is successful ", \
584                schCellDelRsp->cellId);
585          GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
586          if(macCb.macCell[cellIdx])
587          {
588             if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
589             {
590                cause = SUCCESSFUL;
591                for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++)
592                {
593                   if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai)
594                   {
595                      for(sliceIdx = 0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.numSupportedSlices; sliceIdx++)
596                      {
597                         MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai[sliceIdx], sizeof(Snssai));
598                      }
599                      MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].suppSliceList.snssai, macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].\
600                            suppSliceList.numSupportedSlices * sizeof(Snssai*));
601                   }
602                }
603                MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, \
604                      macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen);
605                MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
606             }
607             else
608             {
609                DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
610                cause = CELLID_INVALID;
611                ret = RFAILED;
612             }
613          }
614          else
615          {
616             DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
617             cause = CELLID_INVALID;
618             ret = RFAILED;
619          }
620       }
621       else
622       {
623          DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
624          cause = CELLID_INVALID;
625          ret = RFAILED;
626       }
627       if(MacSendCellDeleteRsp(cause, schCellDelRsp->cellId) != ROK)
628       {
629          DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
630          ret = RFAILED;
631       }
632
633    }
634    else
635    {
636       DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
637       ret = RFAILED;
638    }
639    return ret;
640 }
641
642 /*******************************************************************
643  *
644  * @brief Sends Cell delete req to Scheduler
645  *
646  * @details
647  *
648  *    Function : sendCellDelReqToSch
649  *
650  *    Functionality: sends Cell delete req to Scheduler
651  *
652  * @params[in]  SchCellDelete *schCellDel
653  * @return ROK     - success
654  *         RFAILED - failure
655  *
656  * ****************************************************************/
657
658 uint8_t sendCellDelReqToSch(SchCellDeleteReq *schCellDelReq)
659 {
660    Pst schPst;
661    FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
662    return(SchMessageRouter(&schPst, (void *)schCellDelReq));
663 }
664
665 /*******************************************************************
666  *
667  * @brief Handles CELL Delete requst from DU APP
668  *
669  * @details
670  *
671  *    Function : MacProcCellDeleteReq
672  *
673  *    Functionality: Handles CELL Delete requst from DU APP
674  *
675  * @params[in] Pst *pst, MacCellDelete *cellDelete
676  * @return ROK     - success
677  *         RFAILED - failure
678  *
679  *
680  * ****************************************************************/
681 uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete)
682 {
683    uint8_t ret = ROK, cellIdx=0;
684    SchCellDeleteReq schCellDelete;
685
686    DU_LOG("\nINFO   -->  MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
687
688    if(cellDelete)
689    {
690       GET_CELL_IDX(cellDelete->cellId, cellIdx);
691       if(macCb.macCell[cellIdx])
692       {
693          if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
694          {
695             memset(&schCellDelete, 0, sizeof(SchCellDeleteReq ));
696             schCellDelete.cellId =  cellDelete->cellId;
697             ret = sendCellDelReqToSch(&schCellDelete);
698             if(ret != ROK)
699             {
700                DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
701                ret = RFAILED;
702             }
703          }
704          else
705          {
706             DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
707             cellDelete->cellId);
708             ret = RFAILED;
709          }
710       }
711       else
712       {
713          DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
714                cellDelete->cellId);
715          ret = RFAILED;
716       }
717
718       if(ret == RFAILED)
719       {
720           DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Sending failure response to DU");
721           if(MacSendCellDeleteRsp(CELLID_INVALID, cellDelete->cellId) != ROK)
722           {
723              DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
724              cellDelete->cellId);
725           }
726
727       }
728       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDeleteReq));
729    }
730    else
731    {
732       DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
733       ret = RFAILED;
734    }
735    return ret;
736 }
737
738 /**
739  * @brief free the temporary slice cfg stored in macCb.
740  *
741  * @details
742  *
743  *     Function : freeMacSliceCfgReq 
744  *
745  *   free the temporary slice cfg stored in macCb
746  *
747  *  @param[in]  
748  *  @return  int
749  *      -# ROK
750  **/
751 void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst)
752 {
753     uint8_t policyIdx = 0, memberListIdx=0;
754
755     if(cfgReq->numOfRrmPolicy)
756     {
757        if(cfgReq->listOfRrmPolicy)
758        {
759           for(policyIdx = 0; policyIdx<cfgReq->numOfRrmPolicy; policyIdx++)
760           {
761              if(cfgReq->listOfRrmPolicy[policyIdx])
762              {
763                 if(cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem)
764                 {
765                    if(cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList)
766                    {
767                       for(memberListIdx = 0; memberListIdx<cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem; memberListIdx++)
768                       {
769                          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx], sizeof(RrmPolicyMemberList));
770                       }
771                       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList,\
772                       cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem * sizeof(RrmPolicyMemberList*));
773                    }
774                 }
775                 MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx], sizeof(MacSliceRrmPolicy));
776              }
777           }
778           MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy, cfgReq->numOfRrmPolicy  * sizeof(MacSliceRrmPolicy*));
779        }
780     }
781
782 }
783
784 /**
785  * @brief send slice cfg response to duapp.
786  *
787  * @details
788  *
789  *     Function : MacSendSliceConfigRsp
790  *
791  *   sends  slice cfg response to duapp
792  *
793  *  @param[in] MacSliceCfgRsp macSliceCfgRsp 
794  *  @return  int
795  *      -# ROK
796  **/
797 uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp)
798 {
799     Pst  rspPst;
800     
801     memset(&rspPst, 0, sizeof(Pst));
802     FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP);
803     return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp);
804
805 }
806
807 /**
808  * @brief Mac process the slice cfg rsp received from sch.
809  *
810  * @details
811  *
812  *     Function : MacProcSchSliceCfgRsp 
813  *
814  *     This function  process the slice cfg rsp received from sch
815  *
816  *  @param[in]  Pst           *pst
817  *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
818  *  @return  int
819  *      -# ROK
820  **/
821
822 uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp)
823 {
824    MacSliceCfgRsp *macSliceCfgRsp = NULLP;
825
826    if(schSliceCfgRsp)
827    {
828       MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
829       if(macSliceCfgRsp == NULLP)
830       {
831           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
832           return RFAILED;
833       }
834       macSliceCfgRsp->snssai = schSliceCfgRsp->snssai;
835       if(schSliceCfgRsp->rsp == RSP_OK)
836          macSliceCfgRsp->rsp    = MAC_DU_APP_RSP_OK;
837       else
838       {
839          macSliceCfgRsp->rsp    = MAC_DU_APP_RSP_NOK;
840       }
841       macSliceCfgRsp->cause  = schSliceCfgRsp->cause;
842       MacSendSliceConfigRsp(macSliceCfgRsp);
843    }
844    return ROK;
845 }
846
847 /**
848  * @brief send slice cfg response to duapp.
849  *
850  * @details
851  *
852  *     Function : MacSendSliceReconfigRsp 
853  *
854  *   sends  slice cfg response to duapp
855  *
856  *  @param[in] MacSliceRecfgRsp macSliceRecfgRsp
857  *  @return  int
858  *      -# ROK
859  **/
860 uint8_t MacSendSliceReconfigRsp(MacSliceRecfgRsp *macSliceRecfgRsp)
861 {
862    Pst  rspPst;
863
864    memset(&rspPst, 0, sizeof(Pst));
865    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
866    return (*macDuSliceRecfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
867
868 }
869
870 /**
871  * @brief Mac process the slice cfg rsp received from sch.
872  *
873  * @details
874  *
875  *     Function : MacProcSchSliceRecfgRsp 
876  *
877  *     This function  process the slice cfg rsp received from sch
878  *
879  *  @param[in]  Pst           *pst
880  *  @param[in]  SchSliceCfgRsp *schSliceRecfgRsp
881  *  @return  int
882  *      -# ROK
883  **/
884 uint8_t MacProcSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *schSliceRecfgRsp)
885 {
886    MacSliceRecfgRsp *macSliceRecfgRsp = NULLP;
887
888    if(schSliceRecfgRsp)
889    {
890       MAC_ALLOC_SHRABL_BUF(macSliceRecfgRsp, sizeof(MacSliceRecfgRsp));
891       if(macSliceRecfgRsp == NULLP)
892       {
893           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp");
894           return RFAILED;
895       }
896
897       macSliceRecfgRsp->snssai = schSliceRecfgRsp->snssai;
898       if(schSliceRecfgRsp->rsp == RSP_OK)
899          macSliceRecfgRsp->rsp    = MAC_DU_APP_RSP_OK;
900       else
901       {
902          macSliceRecfgRsp->rsp    = MAC_DU_APP_RSP_NOK;
903       }
904       macSliceRecfgRsp->cause  = schSliceRecfgRsp->cause;
905       MacSendSliceReconfigRsp(macSliceRecfgRsp);
906    }
907    return ROK;
908 }
909
910 /**
911  * @brief Mac process the downlink pcch indication received from DUAPP
912  *
913  * @details
914  *
915  *     Function : MacProcDlPcchInd 
916  *
917  *     This function process the downlink pcch indication received from DUAPP
918  *
919  *  @param[in]  Pst           *pst
920  *  @param[in]  DlPcchInd    *pcchInd 
921  *  @return  int
922  *      -# ROK
923  **/
924 uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd)
925 {
926    uint8_t ret = RFAILED;
927    uint16_t cellIdx = 0;
928    Pst       schPst;
929    SchPageInd *schPageInd = NULLP;
930
931    if(pcchInd)
932    {
933       DU_LOG("\nINFO   -->  MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId);
934       
935       GET_CELL_IDX(pcchInd->cellId, cellIdx);
936
937       if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId)
938       {
939          DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId);
940       }
941       else
942       {
943          if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0))
944          {
945             DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Pcch pdu is null");
946          }
947          else
948          {
949             MAC_ALLOC(schPageInd, sizeof(SchPageInd));
950             if(schPageInd == NULLP)
951             {
952                DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
953             }
954             else
955             {
956                schPageInd->cellId = pcchInd->cellId;
957                schPageInd->pf = pcchInd->pf;
958                schPageInd->i_s = pcchInd->i_s;
959                schPageInd->pduLen = pcchInd->pduLen;
960                
961                MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen);
962                if(schPageInd->pagePdu == NULLP)
963                {
964                   DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
965                   MAC_FREE(schPageInd, sizeof(SchPageInd));
966                }
967                else
968                {
969                   memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen);
970
971                   FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH);
972                   ret = SchMessageRouter(&schPst, (void *)schPageInd);
973                }
974             }
975          }
976       }
977       if((pcchInd->pcchPdu) && (pcchInd->pduLen > 0))
978       {
979          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen);
980       }
981       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(DlPcchInd));
982    }
983    else
984    {
985       DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Null pointer");
986    }
987    return ret;
988 }
989
990 /**
991  * @brief Mac process the downlink Broadcast Req received from DUAPP
992  *
993  * @details
994  *
995  *     Function : MacProcDlBroadcastReq 
996  *
997  *     This function process the downlink Broadcast Req received from DUAPP
998  *
999  *  @param[in]  Pst           *pst
1000  *  @param[in]  DlBroadcastReq    *dlBroadcastReq 
1001  *  @return  int
1002  *      -# ROK
1003  **/
1004 uint8_t MacProcDlBroadcastReq(Pst *pst, MacDlBroadcastReq *dlBroadcastReq)
1005 {
1006    uint8_t ret = ROK, idx=0;
1007    uint16_t cellIdx = 0;
1008
1009    if(dlBroadcastReq)
1010    {
1011       DU_LOG("\nINFO   -->  MAC : Received DL braodcast req from DU_APP for cellId[%d]", dlBroadcastReq->cellId);
1012       
1013       GET_CELL_IDX(dlBroadcastReq->cellId, cellIdx);
1014
1015       if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != dlBroadcastReq->cellId)
1016       {
1017          ret = RFAILED;
1018          DU_LOG("\nERROR  -->  MAC : MacProcDlBroadcastReq(): CellId[%d] does not exist", dlBroadcastReq->cellId);
1019       }
1020       else
1021       {
1022          /*TODO - Complete the processing of DL Broadcast Request*/
1023       }
1024       for(idx = 0; idx<dlBroadcastReq->numSiBlock; idx++)
1025       {
1026          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx]->siAreaID, sizeof(uint8_t));
1027          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx], sizeof(SiSchedulingInfo));
1028       }
1029       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq, sizeof(MacDlBroadcastReq));
1030    }
1031    else
1032    {
1033       ret = RFAILED;
1034       DU_LOG("\nERROR  -->  MAC : MacProcDlBroadcastReq(): Received Null pointer");
1035    }
1036    return ret;
1037 }
1038
1039 /**
1040  * @brief Fill and send statistics response to DU APP
1041  *
1042  * @details
1043  *
1044  *     Function : MacSendStatsRspToDuApp
1045  *
1046  *     Fill and send statistics response to DU APP
1047  *
1048  *  @param[in]  Response
1049  *  @param[in]  Cause of response
1050  *  @return  int
1051  *      -# ROK
1052  **/
1053 uint8_t MacSendStatsRspToDuApp(MacStatsRsp *statsRsp)
1054 {
1055    uint8_t ret = ROK;
1056    Pst  pst;
1057    MacStatsRsp *macStatsRsp = NULLP;
1058
1059     DU_LOG("\nINFO  -->  MAC : MacSendStatsRspToDuApp: Sending Statistics Response to DU APP");
1060
1061    MAC_ALLOC_SHRABL_BUF(macStatsRsp, sizeof(MacStatsRsp));
1062    if(macStatsRsp == NULLP)
1063    {
1064       DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchStatsRsp");
1065       ret = RFAILED;
1066    }
1067    else
1068    {
1069       memcpy(macStatsRsp, statsRsp, sizeof(MacStatsRsp));
1070       memset(statsRsp, 0, sizeof(MacStatsRsp));
1071
1072       memset(&pst, 0, sizeof(Pst));
1073       FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATISTICS_RSP);
1074       if(((*macDuStatsRspOpts[pst.selector])(&pst, macStatsRsp))!= ROK)
1075       {
1076          DU_LOG("\nERROR  -->  MAC : Failed to send statistics response to DU APP");
1077          MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsRsp, sizeof(MacStatsRsp));
1078          ret = RFAILED;
1079       }
1080    }
1081
1082    return ret;
1083 }
1084
1085 /*******************************************************************
1086  *
1087  * @brief Rejects all statistics group requested by DU APP
1088  *
1089  * @details
1090  *
1091  *    Function : MacRejectAllStats
1092  *
1093  *    Functionality: Add all statistics group received in statistics
1094  *       request from DU APP, to Reject-Stats-Group-List in statistics
1095  *       response to DU APP
1096  *
1097  * @params[in]  Statistics request from DU APP
1098  *              Cause of rejection
1099  * @return ROK     - success
1100  *         RFAILED - failure
1101  *
1102  * ****************************************************************/
1103 uint8_t MacRejectAllStats(MacStatsReq *macStatsReq, CauseOfResult cause)
1104 {
1105    uint8_t grpIdx = 0;
1106    MacStatsRsp macStatsRsp;
1107
1108    memset(&macStatsRsp, 0, sizeof(MacStatsRsp));
1109
1110    /* Copying all stats group from stats request to stats response */
1111    macStatsRsp.subscriptionId = macStatsReq->subscriptionId;
1112    for(grpIdx = 0; grpIdx < macStatsReq->numStatsGroup; grpIdx++)
1113    {
1114       macStatsRsp.statsGrpRejectedList[grpIdx].groupId = macStatsReq->statsGrpList[grpIdx].groupId;
1115       macStatsRsp.statsGrpRejectedList[grpIdx].cause = cause;
1116    }
1117    macStatsRsp.numGrpRejected = macStatsReq->numStatsGroup;
1118
1119    return MacSendStatsRspToDuApp(&macStatsRsp);
1120 }
1121
1122 /**
1123  * @brief Mac process the statistics Req received from DUAPP
1124  *
1125  * @details
1126  *
1127  *     Function : MacProcStatsReq
1128  *
1129  *     This function process the statistics request from duapp:
1130  *     [Step 1] Basic validation. If fails, all stats group in stats request are
1131  *     rejected.
1132  *     [Step 2] If basic validations passed, traverse all stats group and
1133  *     validate each measurement types in each group.
1134  *     [Step 3] If any measurement type validation fails in a group, that group 
1135  *     is not configured and it is added to stats-group-rejected-list in
1136  *     mac-stats-response message.
1137  *     [Step 4] Even if one group passes all validation, it is sent to SCH in
1138  *     statistics request. The mac-stats-response message is added to
1139  *     pending-response list. This will be sent to DU APP after stats response
1140  *     is received from SCH.
1141  *     [Step 5] If none of the groups passes all validation, mac-stats-response
1142  *     is sent to du app with all group as part of stats-group-rejected-list.
1143  *
1144  *  @param[in]  Pst      *pst
1145  *  @param[in]  StatsReq *statsReq
1146  *  @return  int
1147  *      -# ROK
1148  **/
1149 uint8_t MacProcStatsReq(Pst *pst, MacStatsReq *macStatsReq)
1150 {
1151    uint8_t       macStatsGrpIdx = 0, macStatsIdx = 0, schStatsGrpIdx = 0, schStatsIdx = 0;
1152    uint8_t       ret = RFAILED;
1153    bool          measTypeInvalid = false;
1154    Pst           schPst;
1155    MacStatsGrpInfo *macStatsGrp = NULLP;
1156    SchStatsReq     *schStatsReq = NULLP;
1157    MacStatsRsp     *macStatsRsp = NULLP;
1158
1159    DU_LOG("\nINFO   -->  MAC : Received Statistics Request from DU_APP");
1160
1161    if(macStatsReq == NULLP)
1162    {
1163       DU_LOG("\nERROR  -->  MAC : MacProcStatsReq(): Received Null pointer");
1164       return RFAILED;
1165    }
1166    
1167    /* [Step 1] Basic validation. If fails, statistics response is sent to DU APP
1168     * that rejectes all stats */
1169
1170    /* If number of statistics request for which response is still pending
1171     * towards DU APP has reached its maximum limit */
1172    if(macCb.statistics.numPendingStatsRsp >= MAX_PENDING_STATS_RSP)
1173    {
1174       DU_LOG("\nERROR  -->  MAC : MacProcStatsReq: Maximum number of statistics response is pending. \
1175          Cannot process new request."); 
1176       MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE);
1177       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq));
1178       return RFAILED;
1179    }
1180
1181    /* If memory resources are unavailable */
1182    MAC_ALLOC(schStatsReq, sizeof(SchStatsReq));
1183    if(schStatsReq == NULLP)
1184    {
1185       DU_LOG("\nERROR  -->  MAC : MacProcStatsReq: Failed to allocate memory");
1186       MacRejectAllStats(macStatsReq, RESOURCE_UNAVAILABLE);
1187       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq));
1188       return RFAILED;
1189    }
1190
1191    /* Add stats response to pending response list */ 
1192    macStatsRsp = &macCb.statistics.pendingStatsRsp[macCb.statistics.numPendingStatsRsp];
1193    memset(macStatsRsp, 0, sizeof(MacStatsRsp));
1194
1195    /* [Step 2] Traverse all stats group and validate each measurement types in each group */
1196    schStatsReq->subscriptionId = macStatsReq->subscriptionId;
1197    schStatsReq->numStatsGroup = 0;
1198    for(macStatsGrpIdx = 0; macStatsGrpIdx < macStatsReq->numStatsGroup; macStatsGrpIdx++)
1199    {
1200       measTypeInvalid = false;
1201       schStatsIdx = 0;
1202       macStatsGrp = &macStatsReq->statsGrpList[macStatsGrpIdx];
1203
1204       for(macStatsIdx=0; macStatsIdx < macStatsGrp->numStats; macStatsIdx++)
1205       {
1206          /* Validate each measurement type */
1207          switch(macStatsGrp->statsList[macStatsIdx])
1208          {
1209             case MAC_DL_TOTAL_PRB_USAGE:
1210                {
1211                   schStatsReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_DL_TOTAL_PRB_USAGE;
1212                   break;
1213                }
1214             case MAC_UL_TOTAL_PRB_USAGE:
1215                {
1216                   schStatsReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_UL_TOTAL_PRB_USAGE;
1217                   break;
1218                }
1219             default:
1220                {
1221                   DU_LOG("\nERROR  -->  MAC : MacProcStatsReq: Invalid measurement type [%d]", \
1222                      macStatsGrp->statsList[macStatsIdx]);
1223                   measTypeInvalid = true;
1224                }
1225          }
1226
1227          /* Even if one measurement type is invalid, this group is rejected */
1228          if(measTypeInvalid)
1229          {
1230             memset(&schStatsReq->statsGrpList[schStatsGrpIdx], 0, sizeof(SchStatsGrpInfo));
1231             break;
1232          }
1233          
1234          schStatsIdx++;
1235       }
1236
1237       /* If all measurement type is valid, add group info to send to SCH */
1238       if(!measTypeInvalid)
1239       {
1240          schStatsReq->statsGrpList[schStatsGrpIdx].groupId = macStatsGrp->groupId;
1241          schStatsReq->statsGrpList[schStatsGrpIdx].periodicity = macStatsGrp->periodicity;
1242          schStatsReq->statsGrpList[schStatsGrpIdx].numStats = schStatsIdx;
1243          schStatsGrpIdx++;
1244       }
1245       else
1246       {
1247          /* [Step 3] If any measurement type validation fails in a group, that group 
1248           * is not configured and it is added to stats-group-rejected-list in
1249           * mac-stats-response message */
1250          macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].groupId = macStatsGrp->groupId;
1251          macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].cause = PARAM_INVALID;
1252          macStatsRsp->numGrpRejected++;
1253       }
1254    }
1255    schStatsReq->numStatsGroup = schStatsGrpIdx;
1256
1257    macStatsRsp->subscriptionId = macStatsReq->subscriptionId;
1258
1259    if(schStatsReq->numStatsGroup)
1260    {
1261       /* [Step 4] Even if one group passes all validation, it is sent to SCH in
1262        * statistics request. The mac-stats-response message is added to
1263        * pending-response list. */     
1264       macCb.statistics.numPendingStatsRsp++;
1265
1266       FILL_PST_MAC_TO_SCH(schPst, EVENT_STATISTICS_REQ_TO_SCH);
1267       ret = SchMessageRouter(&schPst, (void *)schStatsReq);
1268    }
1269    else
1270    {
1271       /* [Step 5] If none of the groups passes all validation, mac-stats-response
1272        * is sent to du app with all group as part of stats-group-rejected-list. */
1273       DU_LOG("\nERROR  -->  MAC : MacProcStatsReq: All statistics group found invalid");
1274       MAC_FREE(schStatsReq, sizeof(SchStatsReq));
1275       ret = MacSendStatsRspToDuApp(macStatsRsp);
1276    }
1277
1278    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsReq, sizeof(MacStatsReq));
1279    return ret;
1280 }
1281
1282 /**
1283  * @brief Mac process the statistics rsp received from sch.
1284  *
1285  * @details
1286  *
1287  *     Function : MacProcSchStatsRsp
1288  *
1289  *     This function  process the statistics response received from sch
1290  *
1291  *  @param[in]  Pst           *pst
1292  *  @param[in]  SchStatsRsp *schStatsRsp
1293  *  @return  int
1294  *      -# ROK
1295  **/
1296 uint8_t MacProcSchStatsRsp(Pst *pst, SchStatsRsp *schStatsRsp)
1297 {
1298    uint8_t idx = 0, accptdIdx = 0, rjctdIdx = 0;
1299    uint8_t ret = RFAILED;
1300    MacStatsRsp *macStatsRsp = NULLP;
1301
1302    if(schStatsRsp)
1303    {
1304       /* Fetch pointer to statistics response from pending list saved at MAC 
1305        * during processing statistics request from DU APP */ 
1306       for(idx = 0; idx < macCb.statistics.numPendingStatsRsp; idx++)
1307       {
1308          if(macCb.statistics.pendingStatsRsp[idx].subscriptionId == schStatsRsp->subscriptionId)
1309          {
1310             macStatsRsp = &macCb.statistics.pendingStatsRsp[idx];
1311             break;
1312          }
1313       }
1314
1315       if(macStatsRsp == NULLP)
1316       {
1317          MAC_FREE(schStatsRsp, sizeof(SchStatsRsp));
1318          return RFAILED;
1319       }
1320       
1321       /* Copy Stats-group-accpeted list received from SCH */
1322       for(accptdIdx = 0; accptdIdx<schStatsRsp->numGrpAccepted && macStatsRsp->numGrpAccepted<MAX_NUM_STATS_GRP; accptdIdx++)
1323       {
1324          macStatsRsp->statsGrpAcceptedList[macStatsRsp->numGrpAccepted++] = schStatsRsp->statsGrpAcceptedList[accptdIdx];
1325       }
1326
1327       /* List together all stats group rejected by MAC and by SCH */
1328       for(rjctdIdx = 0; rjctdIdx < schStatsRsp->numGrpRejected && macStatsRsp->numGrpRejected<MAX_NUM_STATS_GRP; rjctdIdx++)
1329       {
1330          macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].groupId = \
1331             schStatsRsp->statsGrpRejectedList[rjctdIdx].groupId;
1332          macStatsRsp->statsGrpRejectedList[macStatsRsp->numGrpRejected].cause = \
1333             schStatsRsp->statsGrpRejectedList[rjctdIdx].cause;
1334          macStatsRsp->numGrpRejected++;
1335       }
1336       
1337       /* Send statistics response to DU APP */
1338       ret = MacSendStatsRspToDuApp(macStatsRsp);
1339    }
1340    MAC_FREE(schStatsRsp, sizeof(SchStatsRsp));
1341    return ret;
1342 }
1343
1344 /**
1345  * @brief Fill and send statistics delete response to DU APP
1346  *
1347  * @details
1348  *
1349  *     Function : MacSendStatsDeleteRspToDuApp
1350  *
1351  *     Fill and send statistics delete response to DU APP
1352  *  [Step-1] In SCH delete response is received, fill MAC stats delete 
1353  *    response with info from SCH stats delete response.
1354  *  [Step-2] If a failure occurs while processing MAC stats delete request, 
1355  *    then fill MAC stats delete rsp with failure using info from MAC stats delete request.
1356  *  [Step-3] Else if numStatsGroup > 0, then send stats delete response 
1357  *    with deletion status of each stats group.
1358  *  [Step-4] If numStatsGroup = 0, send Stats delete response 
1359  *    for deletion of complete subscription.
1360  *
1361  *  @param[in]  SchStatsDeleteRsp
1362  *  @param[in]  MacStatsDeleteReq
1363  *  @return  int
1364  *      -# ROK
1365  **/
1366 uint8_t MacSendStatsDeleteRspToDuApp(SchStatsDeleteRsp *schStatsDeleteRsp,  MacStatsDeleteReq *macStatsDeleteReq)
1367 {
1368    Pst  pst;
1369    uint8_t ret = ROK, idx=0;
1370    MacStatsDeleteRsp *macStatsDeleteRsp=NULLP;
1371
1372    MAC_ALLOC_SHRABL_BUF(macStatsDeleteRsp, sizeof(MacStatsDeleteRsp));
1373    if(macStatsDeleteRsp == NULLP)
1374    {
1375       DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchStatsDeleteRsp");
1376       ret = RFAILED;
1377    }
1378    
1379    if(schStatsDeleteRsp)
1380    {
1381       /* [Step-1] */ 
1382       macStatsDeleteRsp->subscriptionId = schStatsDeleteRsp->subscriptionId;
1383       macStatsDeleteRsp->numStatsGroupDeleted = schStatsDeleteRsp->numStatsGroupDeleted;
1384
1385       if(macStatsDeleteRsp->numStatsGroupDeleted)
1386       {
1387          /* [Step-3] */ 
1388          for(idx =0;idx<macStatsDeleteRsp->numStatsGroupDeleted; idx++)
1389          {
1390             if(schStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelRsp == RSP_OK)
1391             {
1392                macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelRsp =MAC_DU_APP_RSP_OK;
1393                macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause =schStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause;
1394             }
1395             else
1396             {
1397                macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelRsp =MAC_DU_APP_RSP_NOK;
1398                macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause =schStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause;
1399             }
1400          }
1401       }
1402       else
1403       {
1404          /* [Step-4] */ 
1405          if(schStatsDeleteRsp->subsDelRsp == RSP_OK)
1406             macStatsDeleteRsp->subsDelRsp = MAC_DU_APP_RSP_OK;
1407          else
1408             macStatsDeleteRsp->subsDelRsp = MAC_DU_APP_RSP_NOK;
1409          macStatsDeleteRsp->subsDelCause = schStatsDeleteRsp->subsDelCause;
1410       }
1411    }
1412    else
1413    {
1414       /* [Step-2] */ 
1415       macStatsDeleteRsp->subscriptionId = macStatsDeleteReq->subscriptionId;
1416       macStatsDeleteRsp->numStatsGroupDeleted= macStatsDeleteReq->numStatsGroupToBeDeleted;
1417       
1418       if(macStatsDeleteRsp->numStatsGroupDeleted)
1419       {
1420          /* [Step-3] */ 
1421          for(idx =0;idx<macStatsDeleteRsp->numStatsGroupDeleted; idx++)
1422          {
1423             macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelRsp =MAC_DU_APP_RSP_NOK;
1424             macStatsDeleteRsp->statsGrpDelInfo[idx].statsGrpDelCause = RESOURCE_UNAVAILABLE;
1425          }
1426       }
1427       else
1428       {
1429          /* [Step-4] */ 
1430          macStatsDeleteRsp->subsDelRsp = MAC_DU_APP_RSP_NOK;
1431          macStatsDeleteRsp->subsDelCause = RESOURCE_UNAVAILABLE;
1432       }
1433    }
1434
1435    DU_LOG("\nINFO  -->  MAC : MacSendStatsDeleteRspToDuApp: Sending Delete Statistics Response to DU APP");
1436
1437    memset(&pst, 0, sizeof(Pst));
1438    FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATS_DELETE_RSP);
1439    if(((*macDuStatsDeleteRspOpts[pst.selector])(&pst, macStatsDeleteRsp))!= ROK)
1440    {
1441       DU_LOG("\nERROR  -->  MAC : Failed to send statistics delete response to DU APP");
1442       MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsDeleteRsp, sizeof(MacStatsDeleteRsp));
1443       ret = RFAILED;
1444    }
1445
1446    return ret;
1447 }
1448                  
1449 /**
1450  * @brief Mac process the statistics delete rsp received from sch.
1451  *
1452  * @details
1453  *
1454  *     Function : MacProcSchStatsDeleteRsp
1455  *
1456  *     This function  process the statistics delete response received from sch
1457  *
1458  *  @param[in]  Pst           *pst
1459  *  @param[in]  SchStatsDeleteRsp *schStatsDeleteRsp
1460  *  @return  int
1461  *      -# ROK
1462  **/
1463 uint8_t MacProcSchStatsDeleteRsp(Pst *pst, SchStatsDeleteRsp *schStatsDeleteRsp)
1464 {
1465    uint8_t ret = RFAILED;
1466
1467    if(schStatsDeleteRsp)
1468    {
1469       ret = MacSendStatsDeleteRspToDuApp(schStatsDeleteRsp, NULLP);
1470       MAC_FREE(schStatsDeleteRsp, sizeof(SchStatsDeleteRsp));
1471    }
1472    return ret;
1473 }
1474
1475 /**
1476  * @brief Mac process the statistics delete Req received from DUAPP
1477  *
1478  * @details
1479  *
1480  *     Function : MacProcStatsDeleteReq
1481  *
1482  *     Functionality: Process the statistics delete request from duapp
1483  *  @param[in]  Pst      *pst
1484  *  @param[in]  StatsDeleteReq *statsReq
1485  *  @return  int
1486  *      -# ROK
1487  **/
1488
1489 uint8_t MacProcStatsDeleteReq(Pst *pst, MacStatsDeleteReq *macStatsDeleteReq)
1490 {
1491    Pst       schPst;
1492    uint8_t   ret = RFAILED;
1493    SchStatsDeleteReq  *schStatsDeleteReq = NULLP;
1494  
1495    DU_LOG("\nINFO   -->  MAC : Received Statistics delete Request from DU_APP");
1496
1497    if(macStatsDeleteReq == NULLP)
1498    {
1499       DU_LOG("\nERROR  -->  MAC : MacProcStatsDeleteReq(): Received Null pointer");
1500       return RFAILED;
1501    }
1502    
1503    MAC_ALLOC(schStatsDeleteReq, sizeof(SchStatsDeleteReq));
1504    if(schStatsDeleteReq == NULLP)
1505    {
1506       DU_LOG("\nERROR  -->  MAC : MacProcStatsDeleteReq: Failed to allocate memory");
1507    }
1508    else
1509    {
1510       /* fill all the information in schStatsDeleteReq structure */
1511       schStatsDeleteReq->subscriptionId = macStatsDeleteReq->subscriptionId;
1512       schStatsDeleteReq->numStatsGroupToBeDeleted = macStatsDeleteReq->numStatsGroupToBeDeleted;
1513       memcpy(&schStatsDeleteReq->statsGrpIdToBeDelList, &macStatsDeleteReq->statsGrpIdToBeDelList, schStatsDeleteReq->numStatsGroupToBeDeleted*sizeof(uint8_t)); 
1514       FILL_PST_MAC_TO_SCH(schPst, EVENT_STATISTICS_DELETE_REQ_TO_SCH);
1515       ret = SchMessageRouter(&schPst, (void *)schStatsDeleteReq);
1516    }
1517
1518    if(ret != ROK)
1519    {
1520       ret = MacSendStatsDeleteRspToDuApp(NULLP, macStatsDeleteReq);
1521    }
1522
1523    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsDeleteReq, sizeof(MacStatsDeleteReq));
1524    return ret;
1525 }
1526
1527 /**
1528  * @brief Fill and send statistics modification response to DU APP
1529  *
1530  * @details
1531  *
1532  *     Function : MacSendStatsModificationRspToDuApp 
1533  *
1534  *     Fill and send statistics modification response to DU APP
1535  *
1536  *  @param[in]  Stats modification Response
1537  *  @return  int
1538  *      -# ROK
1539  **/
1540 uint8_t MacSendStatsModificationRspToDuApp(MacStatsModificationRsp *tmpMacStatsModRsp)
1541 {
1542    Pst  pst;
1543    uint8_t ret = ROK;
1544    MacStatsModificationRsp *macStatsModificationRsp = NULLP;
1545
1546    DU_LOG("\nINFO  -->  MAC : MacSendStatsModificationRspToDuApp: Sending Statistics Modification Response to DU APP");
1547
1548
1549    MAC_ALLOC_SHRABL_BUF(macStatsModificationRsp, sizeof(MacStatsModificationRsp));
1550    if(macStatsModificationRsp == NULLP)
1551    {
1552       DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchStatsModificationRsp");
1553       ret = RFAILED;
1554    }
1555    else
1556    {
1557       memcpy(macStatsModificationRsp, tmpMacStatsModRsp, sizeof(MacStatsModificationRsp));
1558       memset(tmpMacStatsModRsp, 0, sizeof(MacStatsModificationRsp));
1559
1560       memset(&pst, 0, sizeof(Pst));
1561       FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_STATISTICS_MODIFY_RSP);
1562       if(((*macDuStatsModificationRspOpts[pst.selector])(&pst, macStatsModificationRsp))!= ROK)
1563       {
1564          DU_LOG("\nERROR  -->  MAC : Failed to send statistics modification response to DU APP");
1565          MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, macStatsModificationRsp, sizeof(MacStatsModificationRsp));
1566          ret = RFAILED;
1567       }
1568    }
1569
1570    return ret;
1571 }
1572
1573 /**
1574  * @brief Mac process the statistics modification rsp received from sch.
1575  *
1576  * @details
1577  *
1578  *     Function : MacProcSchStatsModificationRsp
1579  *
1580  *     This function  process the statistics modification response received from sch
1581  *     [Step -1] Fetch pointer to statistics response from pending list saved at
1582  *     MAC during processing statistics request from DU APP
1583  *     [Step -2] Fill the list of accepted list
1584  *     [Step -3] Fill the list of rejected list
1585  *     [Step -4] Send statistics modification response to DU APP
1586  *
1587  *  @param[in]  Pst           *pst
1588  *  @param[in]  SchStatsModificationRsp *schStatsModificationRsp
1589  *  @return  int
1590  *      -# ROK
1591  **/
1592 uint8_t MacProcSchStatsModificationRsp(Pst *pst, SchStatsModificationRsp *schStatsModificationRsp)
1593 {
1594    uint8_t ret = RFAILED;
1595    uint8_t idx = 0, accptdIdx = 0, rjctdIdx = 0;
1596    MacStatsModificationRsp *macStatsModificationRsp = NULLP;
1597
1598    if(schStatsModificationRsp)
1599    {
1600       /* [Step -1] */
1601       for(idx = 0; idx < macCb.statistics.numPendingStatsRsp; idx++)
1602       {
1603          if(macCb.statistics.pendingStatsRsp[idx].subscriptionId == schStatsModificationRsp->subscriptionId)
1604          {
1605             macStatsModificationRsp = &macCb.statistics.pendingStatsRsp[idx];
1606             break;
1607          }
1608       }
1609
1610       if(macStatsModificationRsp == NULLP)
1611       {
1612          MAC_FREE(schStatsModificationRsp, sizeof(SchStatsModificationRsp));
1613          return RFAILED;
1614       }
1615       
1616       /* [Step -2] */
1617       for(accptdIdx = 0; accptdIdx<schStatsModificationRsp->numGrpAccepted && macStatsModificationRsp->numGrpAccepted<MAX_NUM_STATS_GRP; accptdIdx++)
1618       {
1619          macStatsModificationRsp->statsGrpAcceptedList[macStatsModificationRsp->numGrpAccepted++] = schStatsModificationRsp->statsGrpAcceptedList[accptdIdx];
1620       }
1621
1622       /* [Step -3] */
1623       for(rjctdIdx = 0; rjctdIdx < schStatsModificationRsp->numGrpRejected && macStatsModificationRsp->numGrpRejected<MAX_NUM_STATS_GRP; rjctdIdx++)
1624       {
1625          macStatsModificationRsp->statsGrpRejectedList[macStatsModificationRsp->numGrpRejected].groupId = \
1626             schStatsModificationRsp->statsGrpRejectedList[rjctdIdx].groupId;
1627          macStatsModificationRsp->statsGrpRejectedList[macStatsModificationRsp->numGrpRejected].cause = \
1628             schStatsModificationRsp->statsGrpRejectedList[rjctdIdx].cause;
1629          macStatsModificationRsp->numGrpRejected++;
1630       }
1631
1632       /* [Step -4] */
1633       ret = MacSendStatsModificationRspToDuApp(macStatsModificationRsp);
1634    }
1635    MAC_FREE(schStatsModificationRsp, sizeof(SchStatsModificationRsp));
1636    return ret;
1637 }
1638
1639 /*******************************************************************
1640  *
1641  * @brief Rejects all statistics modification group requested by DU APP
1642  *
1643  * @details
1644  *
1645  *    Function : MacRejectAllStatsModification
1646  *
1647  *    Functionality: Add all statistics modification group received in statistics
1648  *       request from DU APP, to Reject-StatsModification-Group-List in statistics
1649  *       response to DU APP
1650  *
1651  * @params[in]  Statistics request from DU APP
1652  *              Cause of rejection
1653  * @return ROK     - success
1654  *         RFAILED - failure
1655  *
1656  * ****************************************************************/
1657 uint8_t MacRejectAllStatsModification(MacStatsModificationReq *macStatsModificationReq, CauseOfResult cause)
1658 {
1659    uint8_t grpIdx = 0;
1660    MacStatsModificationRsp macStatsModificationRsp;
1661
1662    memset(&macStatsModificationRsp, 0, sizeof(MacStatsModificationRsp));
1663
1664    /* fill the subscriptionId and the rejected list in stats modification rsp */
1665    macStatsModificationRsp.subscriptionId = macStatsModificationReq->subscriptionId;
1666    for(grpIdx = 0; grpIdx < macStatsModificationReq->numStatsGroup; grpIdx++)
1667    {
1668       macStatsModificationRsp.statsGrpRejectedList[grpIdx].groupId = macStatsModificationReq->statsGrpList[grpIdx].groupId;
1669       macStatsModificationRsp.statsGrpRejectedList[grpIdx].cause = cause;
1670    }
1671    macStatsModificationRsp.numGrpRejected = macStatsModificationReq->numStatsGroup;
1672
1673    return MacSendStatsModificationRspToDuApp(&macStatsModificationRsp);
1674 }
1675
1676 /**
1677  * @brief Mac process the statistics Modification Req received from DUAPP
1678  *
1679  * @details
1680  *
1681  *     Function : MacProcStatsModificationReq
1682  *
1683  *     This function process the statistics Modification request from duapp:
1684  *     [Step 1] Basic validation. If fails, all stats group in stats request are
1685  *     rejected.
1686  *     [Step 2] If basic validations passed, traverse all stats group and
1687  *     validate each measurement types in each group.
1688  *     [Step 3] If any measurement type validation fails in a group, that group
1689  *     is not configured and it is added to stats-group-rejected-list in
1690  *     mac-stats-response message.
1691  *     [Step 4] Even if one group passes all validation, it is sent to SCH in
1692  *     statistics request. The mac-stats-response message is added to
1693  *     pending-response list. This will be sent to DU APP after stats response
1694  *     is received from SCH.
1695  *     [Step 5] If none of the groups passes all validation, mac-stats-response
1696  *     is sent to du app with all group as part of stats-group-rejected-list.
1697  *
1698  *  @param[in]  Pst      *pst
1699  *  @param[in]  StatsModificationReq *statsModificationReq
1700  *  @return  int
1701  *      -# ROK
1702  **/
1703 uint8_t MacProcStatsModificationReq(Pst *pst, MacStatsModificationReq *macStatsModificationReq)
1704 {
1705    Pst           schPst;
1706    uint8_t       ret = RFAILED;
1707    bool          measTypeInvalid = false;
1708    uint8_t       macStatsGrpIdx = 0, macStatsIdx = 0;
1709    uint8_t       schStatsGrpIdx = 0, schStatsIdx = 0;
1710    MacStatsGrpInfo          *macStatsGrp = NULLP;
1711    SchStatsModificationReq  *schStatsModificationReq = NULLP;
1712    MacStatsModificationRsp  *macStatsModificationRsp = NULLP;
1713
1714    DU_LOG("\nINFO   -->  MAC : Received Statistics Modification Request from DU_APP");
1715
1716    if(macStatsModificationReq == NULLP)
1717    {
1718       DU_LOG("\nERROR  -->  MAC : MacProcStatsModificationReq(): Received Null pointer");
1719       return RFAILED;
1720    }
1721
1722    /* [Step -1] */
1723    if(macCb.statistics.numPendingStatsRsp >= MAX_PENDING_STATS_RSP)
1724    {
1725       DU_LOG("\nERROR  -->  MAC : MacProcStatsModificationReq: Maximum number of statistics response is pending. \
1726          Cannot process new request.");
1727       MacRejectAllStatsModification(macStatsModificationReq, RESOURCE_UNAVAILABLE);
1728       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsModificationReq, sizeof(MacStatsModificationReq));
1729       return RFAILED;
1730    }
1731
1732    MAC_ALLOC(schStatsModificationReq, sizeof(SchStatsModificationReq));
1733    if(schStatsModificationReq == NULLP)
1734    {
1735       DU_LOG("\nERROR  -->  MAC : MacProcStatsModificationReq: Failed to allocate memory");
1736       MacRejectAllStatsModification(macStatsModificationReq, RESOURCE_UNAVAILABLE);
1737       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsModificationReq, sizeof(MacStatsModificationReq));
1738       return RFAILED;
1739    }
1740
1741    macStatsModificationRsp = &macCb.statistics.pendingStatsRsp[macCb.statistics.numPendingStatsRsp];
1742    memset(macStatsModificationRsp, 0, sizeof(MacStatsModificationRsp));
1743
1744    /* [Step 2]  */
1745    schStatsModificationReq->subscriptionId = macStatsModificationReq->subscriptionId;
1746    schStatsModificationReq->numStatsGroup = 0;
1747    for(macStatsGrpIdx = 0; macStatsGrpIdx < macStatsModificationReq->numStatsGroup; macStatsGrpIdx++)
1748    {
1749       measTypeInvalid = false;
1750       schStatsIdx = 0;
1751       macStatsGrp = &macStatsModificationReq->statsGrpList[macStatsGrpIdx];
1752
1753       for(macStatsIdx=0; macStatsIdx < macStatsGrp->numStats; macStatsIdx++)
1754       {
1755          switch(macStatsGrp->statsList[macStatsIdx])
1756          {
1757             case MAC_DL_TOTAL_PRB_USAGE:
1758                {
1759                   schStatsModificationReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_DL_TOTAL_PRB_USAGE;
1760                   break;
1761                }
1762             case MAC_UL_TOTAL_PRB_USAGE:
1763                {
1764                   schStatsModificationReq->statsGrpList[schStatsGrpIdx].statsList[schStatsIdx] = SCH_UL_TOTAL_PRB_USAGE;
1765                   break;
1766                }
1767             default:
1768                {
1769                   DU_LOG("\nERROR  -->  MAC : MacProcStatsModificationReq: Invalid measurement type [%d]", \
1770                      macStatsGrp->statsList[macStatsIdx]);
1771                   measTypeInvalid = true;
1772                }
1773          }
1774
1775          if(measTypeInvalid)
1776          {
1777             memset(&schStatsModificationReq->statsGrpList[schStatsGrpIdx], 0, sizeof(SchStatsGrpInfo));
1778             break;
1779          }
1780
1781          schStatsIdx++;
1782       }
1783
1784       if(!measTypeInvalid)
1785       {
1786          schStatsModificationReq->statsGrpList[schStatsGrpIdx].groupId = macStatsGrp->groupId;
1787          schStatsModificationReq->statsGrpList[schStatsGrpIdx].periodicity = macStatsGrp->periodicity;
1788          schStatsModificationReq->statsGrpList[schStatsGrpIdx].numStats = schStatsIdx;
1789          schStatsGrpIdx++;
1790       }
1791       else
1792       {
1793          /* [Step 3] */
1794          macStatsModificationRsp->statsGrpRejectedList[macStatsModificationRsp->numGrpRejected].groupId = macStatsGrp->groupId;
1795          macStatsModificationRsp->statsGrpRejectedList[macStatsModificationRsp->numGrpRejected].cause = PARAM_INVALID;
1796          macStatsModificationRsp->numGrpRejected++;
1797       }
1798    }
1799    schStatsModificationReq->numStatsGroup = schStatsGrpIdx;
1800
1801    macStatsModificationRsp->subscriptionId = macStatsModificationReq->subscriptionId;
1802    if(schStatsModificationReq->numStatsGroup)
1803    {
1804       /* [Step 4] */
1805       macCb.statistics.numPendingStatsRsp++;
1806
1807       FILL_PST_MAC_TO_SCH(schPst, EVENT_STATISTICS_MODIFY_REQ_TO_SCH);
1808       ret = SchMessageRouter(&schPst, (void *)schStatsModificationReq);
1809    }
1810    else
1811    {
1812       /* [Step 5] */
1813       DU_LOG("\nERROR  -->  MAC : MacProcStatsModificationReq: All statistics group found invalid");
1814       MAC_FREE(schStatsModificationReq, sizeof(SchStatsModificationReq));
1815       ret = MacSendStatsModificationRspToDuApp(macStatsModificationRsp);
1816    }
1817
1818    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macStatsModificationReq, sizeof(MacStatsModificationReq));
1819    return ret;
1820 }
1821
1822 /**********************************************************************
1823   End of file
1824  **********************************************************************/