fae023324e9a7bfe186f7aeb8de71208288c729d
[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 SchCellCfgFunc SchCellCfgOpts[] =
46 {
47    packSchCellCfg,   /* packing for loosely coupled */
48    SchHdlCellCfgReq, /* packing for tightly coupled */
49    packSchCellCfg    /* packing for light weight loosly coupled */
50 };
51
52 MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]=
53 {
54    packMacSchCellDeleteReq,    /* packing for loosely coupled */
55    MacSchCellDeleteReq,        /* packing for tightly coupled */
56    packMacSchCellDeleteReq     /* packing for light weight loosely coupled */
57 };
58
59 MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
60 {
61    packDuMacCellDeleteRsp,   /* packing for loosely coupled */
62    DuProcMacCellDeleteRsp,   /* packing for tightly coupled */
63    packDuMacCellDeleteRsp   /* packing for light weight loosly coupled */
64 };
65
66 MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] =
67 {
68    packDuMacSliceCfgRsp,   /* packing for loosely coupled */
69    DuProcMacSliceCfgRsp,   /* packing for tightly coupled */
70    packDuMacSliceCfgRsp   /* packing for light weight loosly coupled */
71 };
72
73 MacDuSliceReCfgRspFunc macDuSliceReCfgRspOpts[] =
74 {
75    packDuMacSliceReCfgRsp,   /* packing for loosely coupled */
76    DuProcMacSliceReCfgRsp,   /* packing for tightly coupled */
77    packDuMacSliceReCfgRsp   /* packing for light weight loosly coupled */
78 };
79
80 MacSchPagingIndFunc macSchPagingIndOpts[] = 
81 {
82    packMacSchPagingInd,   /* packing for loosely coupled */
83    MacSchPagingInd,       /* packing for tightly coupled */
84    packMacSchPagingInd    /* packing for light weight loosely 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    printf("\nReceived Scheduler gen config at MAC");
107    memset(&schPst, 0, sizeof(Pst));
108    FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG);
109    SchProcGenCfgReq(&schPst, cfg);
110
111    return ROK;
112 }
113
114 /**
115  * @brief Layer Manager Configuration response from Scheduler
116  *
117  * @details
118  *
119  *     Function : SchSendCfgCfm
120  *
121  *     This function sends general configurations response from
122  *     Scheduler to DU APP.
123  *
124  *  @param[in]  Pst *pst, the post structure
125  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
126  *  @return 
127  *      -# ROK
128  **/
129 uint8_t SchSendCfgCfm(Pst *pst, RgMngmt  *cfm)
130 {
131    DU_LOG("\nDEBUG  -->  Sending Scheduler config confirm to DU APP");
132    pst->dstEnt = ENTDUAPP;
133    pst->dstInst = 0;
134    pst->srcInst = 0;
135    pst->selector = ODU_SELECTOR_LC;
136    RgMiLrgSchCfgCfm(pst, cfm);
137
138    return ROK;
139 }
140
141 /**
142  * @brief Layer Manager Configuration request handler.
143  *
144  * @details
145  *
146  *     Function : MacProcCellCfgReq
147  *
148  *     This function handles the gNB and cell configuration
149  *     request received from DU APP.
150  *     This API unapcks and forwards the config towards SCH
151  *
152  *  @param[in]  Pst           *pst
153  *  @param[in]  MacCellCfg    *macCellCfg
154  *  @return  
155  *      -# ROK
156  **/
157 uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
158 {
159    Pst cfmPst;
160    uint16_t cellIdx;
161    uint8_t ret = ROK, sliceIdx = 0;
162    MacCellCb     *macCellCb;
163
164    memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
165
166    MAC_ALLOC(macCellCb, sizeof(MacCellCb));
167    if(macCellCb == NULLP)
168    {
169       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of macCellCfg\n");
170       return RFAILED;
171    }
172    memset(macCellCb, 0, sizeof(MacCellCb));
173
174    GET_CELL_IDX(macCellCfg->cellId, cellIdx);
175    macCb.macCell[cellIdx] = macCellCb;
176    macCb.macCell[cellIdx]->cellId = macCellCfg->cellId;
177    memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg));
178
179    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
180          macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
181    if(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu == NULLP)
182    {
183       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
184       return RFAILED;
185    }
186    memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \
187          macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
188    
189    macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice = macCellCfg->plmnInfoList.numSupportedSlice;
190    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice\
191          * sizeof(Snssai*));
192    if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai == NULLP)
193    {
194       DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
195       return RFAILED;
196    }
197
198    if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
199    {
200       for(sliceIdx=0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
201       {
202          if(macCellCfg->plmnInfoList.snssai[sliceIdx])
203          {
204             MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
205             if(!macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx])
206             {
207                DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
208                return RFAILED;
209             }
210             memcpy(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],\
211             sizeof(Snssai));
212          }
213       }
214    }
215
216    /* Send cell cfg to scheduler */
217    ret = MacSchCellCfgReq(pst, macCellCfg);
218    if(ret != ROK)
219    {
220       MacCellCfgCfm macCellCfgCfm;
221       macCellCfgCfm.rsp = RSP_NOK;
222       macCellCfgCfm.cellId = macCellCfg->cellId;
223       /* Fill Pst */
224       FILL_PST_MAC_TO_DUAPP(cfmPst, EVENT_MAC_CELL_CONFIG_CFM);
225       cfmPst.selector  = ODU_SELECTOR_LC;
226
227       ret = (*packMacCellCfmOpts[cfmPst.selector])(&cfmPst,&macCellCfgCfm);
228    }
229    else
230    {
231       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
232    }
233    return ret;
234 } /* end of MacProcCellCfgReq */
235
236 /**
237  * @brief Layer Manager Configuration request handler.
238  *
239  * @details
240  *
241  *     Function : MacSchCellCfgReq
242  *
243  *     This function sends cell configuration to SCH
244  *
245  *  @param[in]  Pst           *pst
246  *  @param[in]  MacCellCfg    *macCellCfg
247  *  @return  
248  *      -# ROK
249  **/
250 uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
251 {
252    SchCellCfg schCellCfg;
253    Pst        cfgPst;
254    uint8_t    ssbMaskIdx = 0, rsrcListIdx = 0, ret=0, sliceIdx=0;
255
256    memset(&cfgPst, 0, sizeof(Pst));
257    memset(&schCellCfg, 0, sizeof(SchCellCfg));
258    schCellCfg.cellId = macCellCfg->cellId;
259    schCellCfg.phyCellId = macCellCfg->phyCellId;
260    schCellCfg.numerology = macCellCfg->numerology;
261    schCellCfg.dupMode = macCellCfg->dupType;
262    schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
263    schCellCfg.dlFreq = macCellCfg->dlCarrCfg.freq;
264    schCellCfg.ulFreq = macCellCfg->ulCarrCfg.freq;
265
266    /* fill ssb scheduler parameters */
267    schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
268    schCellCfg.ssbSchCfg.scsCommon = macCellCfg->ssbCfg.scsCmn;
269    schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
270    schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
271    schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
272    for(ssbMaskIdx=0; ssbMaskIdx<SSB_MASK_SIZE; ssbMaskIdx++)
273    {
274       schCellCfg.ssbSchCfg.nSSBMask[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx];
275    }
276    schCellCfg.ssbSchCfg.totNumSsb = countSetBits(schCellCfg.ssbSchCfg.nSSBMask[0]);
277
278    /* fill SIB1 scheduler parameters */
279    schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen;
280    schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod;
281    schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex;
282    schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex;
283    schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs;
284    schCellCfg.sib1SchCfg.pageCfg.numPO  =  macCellCfg->sib1Cfg.pagingCfg.numPO;
285    schCellCfg.sib1SchCfg.pageCfg.poPresent = macCellCfg->sib1Cfg.pagingCfg.poPresent;
286
287    if(schCellCfg.sib1SchCfg.pageCfg.poPresent)
288    {
289       memcpy(schCellCfg.sib1SchCfg.pageCfg.pagingOcc, macCellCfg->sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF);
290    }
291
292    /* fill RACH config params */
293    schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx;
294    schCellCfg.schRachCfg.prachSubcSpacing = \
295                                             macCellCfg->prachCfg.prachSubcSpacing;
296    schCellCfg.schRachCfg.msg1FreqStart = macCellCfg->prachCfg.msg1FreqStart;
297    schCellCfg.schRachCfg.msg1Fdm       = macCellCfg->prachCfg.msg1Fdm;
298    schCellCfg.schRachCfg.rootSeqLen    = macCellCfg->prachCfg.rootSeqLen;
299    schCellCfg.schRachCfg.rootSeqIdx    = macCellCfg->prachCfg.fdm[0].rootSeqIdx;
300    schCellCfg.schRachCfg.numRootSeq    = macCellCfg->prachCfg.fdm[0].numRootSeq;
301    schCellCfg.schRachCfg.k1            = macCellCfg->prachCfg.fdm[0].k1;
302    schCellCfg.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble;
303    schCellCfg.schRachCfg.ssbPerRach    = macCellCfg->prachCfg.ssbPerRach;
304    schCellCfg.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb;
305    schCellCfg.schRachCfg.prachMultCarrBand = macCellCfg->prachCfg.prachMultCarrBand;
306    schCellCfg.schRachCfg.raContResTmr  = macCellCfg->prachCfg.raContResTmr;
307    schCellCfg.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb;
308    schCellCfg.schRachCfg.raRspWindow   = macCellCfg->prachCfg.raRspWindow;
309
310    /* fill initial DL BWP */
311    schCellCfg.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialDlBwp.bwp.firstPrb;
312    schCellCfg.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialDlBwp.bwp.numPrb;
313    schCellCfg.schInitialDlBwp.bwp.scs = macCellCfg->initialDlBwp.bwp.scs;
314    schCellCfg.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->initialDlBwp.bwp.cyclicPrefix;
315    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId =
316       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId;
317    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId =
318       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.coresetId;
319    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot =
320       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot;
321    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration =
322       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.duration;
323    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol =
324       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol;
325    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 =
326       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1;
327    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 =
328       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2;
329    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 =
330       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4;
331    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 =
332       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8;
333    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 =
334       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16;
335    schCellCfg.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc;
336    for(rsrcListIdx = 0; rsrcListIdx<macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++)
337    {
338       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = 
339          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0;
340       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
341          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
342       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
343          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
344       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol =
345          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol;
346    }
347
348    /* fill initial UL BWP */
349    schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb;
350    schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb;
351    schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs;
352    schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix;
353    schCellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \
354       macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc;
355    for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++)
356    {
357       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = 
358          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2;
359       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
360          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
361       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
362          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
363       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength =
364          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength;
365    }
366
367    if(macCellCfg->plmnInfoList.snssai) 
368    {
369       schCellCfg.plmnInfoList.numSliceSupport = macCellCfg->plmnInfoList.numSupportedSlice;
370       MAC_ALLOC(schCellCfg.plmnInfoList.snssai, schCellCfg.plmnInfoList.numSliceSupport * sizeof(Snssai*));
371       if(!schCellCfg.plmnInfoList.snssai)
372       {
373          DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
374          return RFAILED;
375       }
376       for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
377       {
378          if(macCellCfg->plmnInfoList.snssai[sliceIdx])
379          {
380             MAC_ALLOC(schCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
381             if(!schCellCfg.plmnInfoList.snssai[sliceIdx])
382             {
383                DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
384                return RFAILED;
385             }
386             memcpy(schCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],  sizeof(Snssai));
387          }
388       }
389    }
390
391 #ifdef NR_TDD
392    memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
393 #endif
394
395    FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG);
396
397    ret = (*SchCellCfgOpts[cfgPst.selector])(&cfgPst, &schCellCfg);
398    return ret;
399 } /* end of MacSchCellCfgReq */
400
401
402 /*******************************************************************
403  *
404  * @brief Sends Cell config confirm to DU APP
405  *
406  * @details
407  *
408  *    Function : MacSendCellCfgCfm
409  *
410  *    Functionality:
411  *      Sends Cell config confirm to DU APP
412  *
413  * @params[in] Response status
414  * @return void
415  *
416  * ****************************************************************/
417 void MacSendCellCfgCfm(uint16_t cellId, uint8_t response)
418 {
419    Pst pst;
420    uint16_t   cellIdx;
421    MacCellCfgCfm macCellCfgCfm;
422
423    memset(&pst, 0, sizeof(Pst));
424
425    GET_CELL_IDX(cellId, cellIdx);
426    macCellCfgCfm.cellId = macCb.macCell[cellIdx]->macCellCfg.cellId;
427    macCellCfgCfm.rsp = response;
428
429    /* Fill Pst */
430    FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_CELL_CONFIG_CFM);
431    pst.selector  = ODU_SELECTOR_LC;
432
433    (*packMacCellCfmOpts[pst.selector])(&pst,&macCellCfgCfm);
434 }
435
436
437 /**
438  * @brief Layer Manager Configuration response handler.
439  *
440  * @details
441  *
442  *     Function : MacProcSchCellCfgCfm
443  *
444  *     This function processes cell configuration to SCH
445  *
446  *  @param[in]  Pst           *pst
447  *  @param[in]  SchCellCfgCfm *schCellCfgCfm
448  *  @return  int
449  *      -# ROK
450  **/
451 uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm)
452 {
453    uint16_t *cellId = NULLP;
454
455 #ifdef CALL_FLOW_DEBUG_LOG
456    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
457 #endif
458
459    if(schCellCfgCfm->rsp == RSP_OK)
460    {
461       cellId = &schCellCfgCfm->cellId;
462 #ifdef INTEL_TIMER_MODE
463       sendToLowerMac(UL_IQ_SAMPLE, 0, (void *)cellId);
464 #else
465       sendToLowerMac(CONFIG_REQUEST, 0, (void *)cellId);
466 #endif
467    }
468    else
469    {
470       MacSendCellCfgCfm(schCellCfgCfm->cellId, RSP_NOK);
471    }
472    return ROK;
473 }
474
475 /*******************************************************************
476  *
477  * @brief MAC handler for config response from PHY
478  *
479  * @details
480  *
481  *    Function : fapiMacConfigRsp
482  *
483  *    Functionality:
484  *     Processes config response from PHY and sends cell config
485  *     confirm to DU APP
486  *
487  * @params[in]
488  * @return void
489  *
490  * ****************************************************************/
491 void fapiMacConfigRsp(uint16_t cellId)
492 {
493    /* TODO : Processing of config response from PHY */
494
495    /* Send cell config cfm to DU APP */
496    MacSendCellCfgCfm(cellId, RSP_OK);
497 }
498
499 /*******************************************************************
500  *
501  * @brief Fill and Send Cell Delete response from MAC to DU APP
502  *
503  * @details
504  *
505  *    Function : MacSendCellDeleteRsp
506  *
507  *    Functionality: Fill and Send Cell Delete response from MAC to DUAPP
508  *
509  * @params[in] MAC Cell delete result
510  *             SCH Cell delete response
511  * @return ROK     - success
512  *         RFAILED - failure
513  *
514  * ****************************************************************/
515 uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId)
516 {
517    MacCellDeleteRsp *deleteRsp=NULLP;
518    Pst            rspPst;
519
520    MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
521    if(!deleteRsp)
522    {
523       DU_LOG("\nERROR  -->  MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
524       return RFAILED;
525    }
526
527    /* Filling CELL delete response */
528    
529    memset(deleteRsp, 0, sizeof(MacCellDeleteRsp));
530    deleteRsp->cellId = cellId;
531    deleteRsp->result = result;
532
533    /* Fill Post structure and send CELL delete response*/
534    memset(&rspPst, 0, sizeof(Pst));
535    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
536    return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
537 }
538
539 /*******************************************************************
540  *
541  * @brief  Processes CELL delete response from scheduler
542  *
543  * @details
544  *
545  *    Function : MacProcSchCellDeleteRsp
546  *
547  *    Functionality:
548  *      Processes CELL delete from scheduler
549  *
550  * @params[in] Pst : Post structure
551  *             schCellDelRsp : Scheduler CELL delete respons
552  * @return ROK     - success
553  *         RFAILED - failure
554  *
555  * * ****************************************************************/
556 uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
557 {
558    uint8_t  ret = ROK, sliceIdx = 0;
559    uint16_t cellIdx=0;
560    CellDeleteStatus status;
561    
562 #ifdef CALL_FLOW_DEBUG_LOG
563    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
564 #endif  
565
566    if(schCellDelRsp)
567    {
568       if(schCellDelRsp->rsp == RSP_OK)
569       {
570          DU_LOG("\nINFO   -->  MAC : SCH CELL Delete response for cellId[%d] is successful ", \
571          schCellDelRsp->cellId);
572          GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
573          if(macCb.macCell[cellIdx])
574          {
575             if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
576             {
577                status  = SUCCESSFUL_RSP;
578                if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
579                {
580                   for(sliceIdx = 0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
581                   {
582                      MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
583                   }
584                   MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.\
585                   numSupportedSlice * sizeof(Snssai*));
586                }
587                MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
588                   macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
589                MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
590             }
591             else
592             {
593                 DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
594                 status = CELL_ID_INVALID;
595                 ret = RFAILED;
596             }
597          }
598          else
599          {
600             DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
601             status = CELL_ID_INVALID;
602             ret = RFAILED;
603          }
604       }
605       else
606       {
607          DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
608          status = CELL_ID_INVALID;
609          ret = RFAILED;
610       }
611       if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK)
612       {
613          DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
614          ret = RFAILED;
615       }
616
617    }
618    else
619    {
620       DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
621       ret = RFAILED;
622    }
623    return ret;
624 }
625
626 /*******************************************************************
627  *
628  * @brief Sends Cell delete req to Scheduler
629  *
630  * @details
631  *
632  *    Function : sendCellDelReqToSch
633  *
634  *    Functionality: sends Cell delete req to Scheduler
635  *
636  * @params[in]  SchCellDelete *schCellDel
637  * @return ROK     - success
638  *         RFAILED - failure
639  *
640  * ****************************************************************/
641
642 uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel)
643 {
644    Pst schPst;
645    FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
646    return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel);
647 }
648
649 /*******************************************************************
650  *
651  * @brief Handles CELL Delete requst from DU APP
652  *
653  * @details
654  *
655  *    Function : MacProcCellDeleteReq
656  *
657  *    Functionality: Handles CELL Delete requst from DU APP
658  *
659  * @params[in] Pst *pst, MacCellDelete *cellDelete
660  * @return ROK     - success
661  *         RFAILED - failure
662  *
663  *
664  * ****************************************************************/
665 uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
666 {
667    uint8_t ret = ROK, cellIdx=0;
668    SchCellDelete schCellDelete;
669
670    DU_LOG("\nINFO   -->  MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
671
672    if(cellDelete)
673    {
674       GET_CELL_IDX(cellDelete->cellId, cellIdx);
675       if(macCb.macCell[cellIdx])
676       {
677          if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
678          {
679             memset(&schCellDelete, 0, sizeof(SchCellDelete));
680             schCellDelete.cellId =  cellDelete->cellId;
681             ret = sendCellDelReqToSch(&schCellDelete);
682             if(ret != ROK)
683             {
684                DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
685                ret = RFAILED;
686             }
687          }
688          else
689          {
690             DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
691             cellDelete->cellId);
692             ret = RFAILED;
693          }
694       }
695       else
696       {
697          DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
698                cellDelete->cellId);
699          ret = RFAILED;
700       }
701
702       if(ret == RFAILED)
703       {
704           DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Sending failure response to DU");
705           if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK)
706           {
707              DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
708              cellDelete->cellId);
709           }
710
711       }
712       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete));
713    }
714    else
715    {
716       DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
717       ret = RFAILED;
718    }
719    return ret;
720 }
721
722 /**
723  * @brief free the temporary slice cfg stored in macCb.
724  *
725  * @details
726  *
727  *     Function : freeMacSliceCfgReq 
728  *
729  *   free the temporary slice cfg stored in macCb
730  *
731  *  @param[in]  
732  *  @return  int
733  *      -# ROK
734  **/
735 void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst)
736 {
737    uint8_t cfgIdx = 0;
738    
739    if(cfgReq)
740    {
741       if(cfgReq->numOfConfiguredSlice)
742       {
743          for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
744          {
745             if(cfgReq->listOfSliceCfg[cfgIdx])
746             {
747                MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio)); 
748             }
749             MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
750          }
751          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg, cfgReq->numOfConfiguredSlice * sizeof(MacSliceRrmPolicy*));
752       }
753       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq, sizeof(MacSliceCfgReq));
754    }
755 }
756 /**
757  * @brief fill Mac Slice Config Rsp
758  *
759  * @details
760  *
761  *     Function : fillMacSliceCfgRsp 
762  *
763  *     This function   fill Mac Slice Config Rsp
764  *
765  *  @param[in]  SchSliceCfgRsp *sliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp,
766  *  uint8_t *count
767  *  @return  int
768  *      -# ROK
769  **/
770 uint8_t fillMacSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp)
771 {
772    
773     bool sliceFound = false;
774     uint8_t cfgIdx = 0;
775
776     macSliceCfgRsp->numSliceCfgRsp  = schSliceCfgRsp->numSliceCfgRsp;
777     MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp,  macSliceCfgRsp->numSliceCfgRsp* sizeof(MacSliceRsp*));
778     if(macSliceCfgRsp->listOfSliceCfgRsp == NULLP)
779     {
780        DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
781        return RFAILED;
782     }
783
784     for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
785     {
786        sliceFound = false;
787        if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
788        {
789           sliceFound = true;
790        }
791
792        MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
793        if(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
794        {
795           DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
796           return RFAILED;
797        }
798
799        macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai;
800        if(sliceFound == true)
801           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_OK;
802        else
803        {
804           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_NOK;
805           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause  = SLICE_NOT_PRESENT;
806        }
807     }
808     return ROK;
809 }
810
811 /**
812  * @brief send slice cfg response to duapp.
813  *
814  * @details
815  *
816  *     Function : MacSendSliceConfigRsp
817  *
818  *   sends  slice cfg response to duapp
819  *
820  *  @param[in] MacSliceCfgRsp macSliceCfgRsp 
821  *  @return  int
822  *      -# ROK
823  **/
824 uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp)
825 {
826     Pst  rspPst;
827     
828     memset(&rspPst, 0, sizeof(Pst));
829     FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP);
830     return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp);
831
832 }
833 /**
834  * @brief free the slice cfg rsp received from sch.
835  *
836  * @details
837  *
838  *     Function : freeSchSliceCfgRsp 
839  *
840  *     This free the slice cfg rsp received from sch
841  *
842  *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
843  *  @return  int
844  *      -# ROK
845  **/
846 void freeSchSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp)
847 {
848    uint8_t cfgIdx = 0;
849
850    if(schSliceCfgRsp)
851    {
852       if(schSliceCfgRsp->numSliceCfgRsp)
853       {
854          for(cfgIdx = 0; cfgIdx< schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
855          {
856             MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
857          }
858          MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
859       }
860    }
861 }
862
863 /**
864  * @brief Mac process the slice cfg rsp received from sch.
865  *
866  * @details
867  *
868  *     Function : MacProcSchSliceCfgRsp 
869  *
870  *     This function  process the slice cfg rsp received from sch
871  *
872  *  @param[in]  Pst           *pst
873  *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
874  *  @return  int
875  *      -# ROK
876  **/
877 uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp)
878 {
879    MacSliceCfgRsp *macSliceCfgRsp = NULLP;
880
881    if(schSliceCfgRsp)
882    {
883       MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
884       if(macSliceCfgRsp == NULLP)
885       {
886           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
887           return RFAILED;
888       }
889       if(schSliceCfgRsp->listOfSliceCfgRsp)
890       {
891          if(fillMacSliceCfgRsp(schSliceCfgRsp, macSliceCfgRsp) != ROK)
892          {
893             DU_LOG("\nERROR  -->  MAC : Failed to fill the slice cfg response");
894             return RFAILED;
895          }
896          MacSendSliceConfigRsp(macSliceCfgRsp);
897       }
898       freeSchSliceCfgRsp(schSliceCfgRsp);
899    }
900    return ROK;
901 }
902
903 /**
904 * @brief send slice cfg response to duapp.
905 *
906 * @details
907 *
908 *     Function : MacSendSliceReconfigRsp 
909 *
910 *   sends  slice cfg response to duapp
911 *
912 *  @param[in] MacSliceCfgRsp macSliceRecfgRsp
913 *  @return  int
914 *      -# ROK
915 **/
916 uint8_t MacSendSliceReconfigRsp(MacSliceCfgRsp *macSliceRecfgRsp)
917 {
918    Pst  rspPst;
919
920    memset(&rspPst, 0, sizeof(Pst));
921    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
922    return (*macDuSliceReCfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
923
924 }
925
926 /**
927  * @brief Mac process the slice cfg rsp received from sch.
928  *
929  * @details
930  *
931  *     Function : MacProcSchSliceReCfgRsp 
932  *
933  *     This function  process the slice cfg rsp received from sch
934  *
935  *  @param[in]  Pst           *pst
936  *  @param[in]  SchSliceCfgRsp *schSliceRecfgRsp
937  *  @return  int
938  *      -# ROK
939  **/
940 uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceRecfgRsp)
941 {
942    MacSliceCfgRsp *macSliceReCfgRsp = NULLP;
943
944    if(schSliceRecfgRsp)
945    {
946       MAC_ALLOC_SHRABL_BUF(macSliceReCfgRsp, sizeof(MacSliceCfgRsp));
947       if(macSliceReCfgRsp == NULLP)
948       {
949           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceReCfgRsp");
950           return RFAILED;
951       }
952
953       if(schSliceRecfgRsp->listOfSliceCfgRsp)
954       {
955          if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceReCfgRsp) != ROK)
956          {
957             DU_LOG("\nERROR  -->  MAC : Failed to fill the slice Recfg response");
958             return RFAILED;
959          }
960          MacSendSliceReconfigRsp(macSliceReCfgRsp);
961       }
962       freeSchSliceCfgRsp(schSliceRecfgRsp);
963    }
964    return ROK;
965 }
966
967 /**
968  * @brief Mac process the downlink pcch indication received from DUAPP
969  *
970  * @details
971  *
972  *     Function : MacProcDlPcchInd 
973  *
974  *     This function process the downlink pcch indication received from DUAPP
975  *
976  *  @param[in]  Pst           *pst
977  *  @param[in]  MacPcchInd    *pcchInd 
978  *  @return  int
979  *      -# ROK
980  **/
981 uint8_t MacProcDlPcchInd(Pst *pst, MacPcchInd *pcchInd)
982 {
983    uint8_t ret = RFAILED;
984    uint16_t cellIdx = 0;
985    Pst       schPst;
986    SchPageInd *schPageInd = NULLP;
987
988    if(pcchInd)
989    {
990       DU_LOG("\nINFO  -->  MAC : Recived pcch request from DU_APP for cellId[%d]", pcchInd->cellId);
991       
992       GET_CELL_IDX(pcchInd->cellId, cellIdx);
993
994       if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId)
995       {
996          DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId);
997       }
998       else
999       {
1000          if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0))
1001          {
1002             DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Pcch pdu is null");
1003          }
1004          else
1005          {
1006             MAC_ALLOC(schPageInd, sizeof(SchPageInd));
1007             if(schPageInd == NULLP)
1008             {
1009                DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
1010             }
1011             else
1012             {
1013                schPageInd->cellId = pcchInd->cellId;
1014                schPageInd->pf = pcchInd->pf;
1015                schPageInd->i_s = pcchInd->i_s;
1016                schPageInd->pduLen = pcchInd->pduLen;
1017                
1018                MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen);
1019                if(schPageInd->pagePdu == NULLP)
1020                {
1021                   DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
1022                   MAC_FREE(schPageInd, sizeof(SchPageInd));
1023                }
1024                else
1025                {
1026                   memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen);
1027
1028                   DU_LOG("\nINFO -->  MAC : Sending paging indication to SCH");
1029                   FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH);
1030                   ret = (*macSchPagingIndOpts[schPst.selector])(&schPst, schPageInd);
1031                }
1032             }
1033          }
1034       }
1035       if((pcchInd->pcchPdu) && (pcchInd->pduLen > 0))
1036       {
1037          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen);
1038       }
1039       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(MacPcchInd));
1040    }
1041    else
1042    {
1043       DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Null pointer");
1044    }
1045    return ret;
1046 }
1047 /**********************************************************************
1048   End of file
1049  **********************************************************************/