X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_cfg_hdl.c;h=23c1bf77afeaf959b303c9d54741b6ba667a3247;hb=531da47c7bfb6ce138a454f66eb184729860beef;hp=a7baf2e0ff16ecac18fd9a0d1857cbd9287dd503;hpb=525b67cf153ba66b8901989cbba11347bebf13f7;p=o-du%2Fl2.git

diff --git a/src/5gnrmac/mac_cfg_hdl.c b/src/5gnrmac/mac_cfg_hdl.c
index a7baf2e0f..23c1bf77a 100644
--- a/src/5gnrmac/mac_cfg_hdl.c
+++ b/src/5gnrmac/mac_cfg_hdl.c
@@ -42,13 +42,26 @@ packMacCellCfgConfirm packMacCellCfmOpts[] =
    packMacCellCfgCfm,    /* packing for light weight loosly coupled */
 };
 
-SchCellCfgFunc SchCellCfgOpts[] =
+MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
 {
-   packSchCellCfg,   /* packing for loosely coupled */
-   SchHdlCellCfgReq, /* packing for tightly coupled */
-   packSchCellCfg    /* packing for light weight loosly coupled */
+   packDuMacCellDeleteRsp,   /* packing for loosely coupled */
+   DuProcMacCellDeleteRsp,   /* packing for tightly coupled */
+   packDuMacCellDeleteRsp   /* packing for light weight loosly coupled */
 };
 
+MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] =
+{
+   packDuMacSliceCfgRsp,   /* packing for loosely coupled */
+   DuProcMacSliceCfgRsp,   /* packing for tightly coupled */
+   packDuMacSliceCfgRsp   /* packing for light weight loosly coupled */
+};
+
+MacDuSliceRecfgRspFunc macDuSliceRecfgRspOpts[] =
+{
+   packDuMacSliceRecfgRsp,   /* packing for loosely coupled */
+   DuProcMacSliceRecfgRsp,   /* packing for tightly coupled */
+   packDuMacSliceRecfgRsp    /* packing for light weight loosly coupled */
+};
 
 /**
  * @brief Layer Manager  Configuration request handler for Scheduler
@@ -67,11 +80,13 @@ SchCellCfgFunc SchCellCfgOpts[] =
  **/
 uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
 {
-   printf("\nReceived Scheduler gen config at MAC");
-   pst->dstInst = DEFAULT_CELLS + 1;
-   SchProcGenCfgReq(pst, cfg);
+   Pst schPst;
 
-   return ROK;
+   DU_LOG("\nINFO  -->  MAC : Received Scheduler gen config at MAC");
+   memset(&schPst, 0, sizeof(Pst));
+   FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG);
+   
+   return(SchMessageRouter(&schPst, (void *)cfg));
 }
 
 /**
@@ -91,7 +106,7 @@ uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
  **/
 uint8_t SchSendCfgCfm(Pst *pst, RgMngmt  *cfm)
 {
-   DU_LOG("\nDEBUG  -->  Sending Scheduler config confirm to DU APP");
+   DU_LOG("\nDEBUG  -->  MAC : Sending Scheduler config confirm to DU APP");
    pst->dstEnt = ENTDUAPP;
    pst->dstInst = 0;
    pst->srcInst = 0;
@@ -121,7 +136,7 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
 {
    Pst cfmPst;
    uint16_t cellIdx;
-   uint8_t ret = ROK;
+   uint8_t ret = ROK, sliceIdx = 0;
    MacCellCb     *macCellCb;
 
    memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
@@ -137,6 +152,7 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
    GET_CELL_IDX(macCellCfg->cellId, cellIdx);
    macCb.macCell[cellIdx] = macCellCb;
    macCb.macCell[cellIdx]->cellId = macCellCfg->cellId;
+   macCb.macCell[cellIdx]->numOfSlots = 10 * (1 << macCellCfg->numerology);
    memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg));
 
    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
@@ -148,6 +164,33 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
    }
    memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \
 	 macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
+   
+   macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice = macCellCfg->plmnInfoList.numSupportedSlice;
+   MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice\
+         * sizeof(Snssai*));
+   if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai == NULLP)
+   {
+      DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
+      return RFAILED;
+   }
+
+   if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
+   {
+      for(sliceIdx=0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
+      {
+         if(macCellCfg->plmnInfoList.snssai[sliceIdx])
+         {
+            MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+            if(!macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx])
+            {
+               DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
+               return RFAILED;
+            }
+            memcpy(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],\
+            sizeof(Snssai));
+         }
+      }
+   }
 
    /* Send cell cfg to scheduler */
    ret = MacSchCellCfgReq(pst, macCellCfg);
@@ -164,12 +207,6 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
    }
    else
    {
-      if(macCellCfg->prachCfg.fdm[0].numUnusedRootSeq != 0)
-      {
-	 MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->prachCfg.fdm[0].unsuedRootSeq,
-	       macCellCfg->prachCfg.fdm[0].numUnusedRootSeq* sizeof(uint8_t));
-      }
-      MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen);
       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
    }
    return ret;
@@ -193,15 +230,17 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
 {
    SchCellCfg schCellCfg;
    Pst        cfgPst;
-   uint8_t    ret =0;
+   uint8_t    ssbMaskIdx = 0, rsrcListIdx = 0, sliceIdx=0;
 
    memset(&cfgPst, 0, sizeof(Pst));
    memset(&schCellCfg, 0, sizeof(SchCellCfg));
    schCellCfg.cellId = macCellCfg->cellId;
    schCellCfg.phyCellId = macCellCfg->phyCellId;
-   schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
    schCellCfg.numerology = macCellCfg->numerology;
    schCellCfg.dupMode = macCellCfg->dupType;
+   schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
+   schCellCfg.dlFreq = macCellCfg->dlCarrCfg.freq;
+   schCellCfg.ulFreq = macCellCfg->ulCarrCfg.freq;
 
    /* fill ssb scheduler parameters */
    schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
@@ -209,18 +248,25 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
    schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
    schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
    schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
-   for(uint8_t idx=0; idx<SSB_MASK_SIZE; idx++)
+   for(ssbMaskIdx=0; ssbMaskIdx<SSB_MASK_SIZE; ssbMaskIdx++)
    {
-      schCellCfg.ssbSchCfg.nSSBMask[idx] = macCellCfg->ssbCfg.ssbMask[idx];
+      schCellCfg.ssbSchCfg.nSSBMask[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx];
    }
+   schCellCfg.ssbSchCfg.totNumSsb = countSetBits(schCellCfg.ssbSchCfg.nSSBMask[0]);
 
    /* fill SIB1 scheduler parameters */
    schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen;
-   schCellCfg.sib1SchCfg.sib1NewTxPeriod = macCellCfg->sib1Cfg.sib1NewTxPeriod;
    schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod;
    schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex;
    schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex;
    schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs;
+   schCellCfg.sib1SchCfg.pageCfg.numPO  =  macCellCfg->sib1Cfg.pagingCfg.numPO;
+   schCellCfg.sib1SchCfg.pageCfg.poPresent = macCellCfg->sib1Cfg.pagingCfg.poPresent;
+
+   if(schCellCfg.sib1SchCfg.pageCfg.poPresent)
+   {
+      memcpy(schCellCfg.sib1SchCfg.pageCfg.pagingOcc, macCellCfg->sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF);
+   }
 
    /* fill RACH config params */
    schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx;
@@ -232,9 +278,10 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
    schCellCfg.schRachCfg.rootSeqIdx    = macCellCfg->prachCfg.fdm[0].rootSeqIdx;
    schCellCfg.schRachCfg.numRootSeq    = macCellCfg->prachCfg.fdm[0].numRootSeq;
    schCellCfg.schRachCfg.k1            = macCellCfg->prachCfg.fdm[0].k1;
+   schCellCfg.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble;
    schCellCfg.schRachCfg.ssbPerRach    = macCellCfg->prachCfg.ssbPerRach;
-   schCellCfg.schRachCfg.prachMultCarrBand = \
-					     macCellCfg->prachCfg.prachMultCarrBand;
+   schCellCfg.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb;
+   schCellCfg.schRachCfg.prachMultCarrBand = macCellCfg->prachCfg.prachMultCarrBand;
    schCellCfg.schRachCfg.raContResTmr  = macCellCfg->prachCfg.raContResTmr;
    schCellCfg.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb;
    schCellCfg.schRachCfg.raRspWindow   = macCellCfg->prachCfg.raRspWindow;
@@ -264,31 +311,69 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8;
    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 =
       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16;
-   schCellCfg.schInitialDlBwp.pdschCommon.k0 = macCellCfg->initialDlBwp.pdschCommon.k0;
-   schCellCfg.schInitialDlBwp.pdschCommon.mappingType =
-      macCellCfg->initialDlBwp.pdschCommon.mappingType;
-   schCellCfg.schInitialDlBwp.pdschCommon.startSymbol =
-      macCellCfg->initialDlBwp.pdschCommon.startSymbol;
-   schCellCfg.schInitialDlBwp.pdschCommon.lengthSymbol =
-      macCellCfg->initialDlBwp.pdschCommon.lengthSymbol;
+   schCellCfg.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc;
+   for(rsrcListIdx = 0; rsrcListIdx<macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++)
+   {
+      schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = 
+         macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0;
+      schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
+         macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
+      schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
+         macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
+      schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol =
+         macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol;
+   }
 
    /* fill initial UL BWP */
    schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb;
    schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb;
    schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs;
    schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix;
-   schCellCfg.schInitialUlBwp.puschCommon.k2 = macCellCfg->initialUlBwp.puschCommon.k2;
-   schCellCfg.schInitialUlBwp.puschCommon.mappingType =
-      macCellCfg->initialUlBwp.puschCommon.mappingType;
-   schCellCfg.schInitialUlBwp.puschCommon.startSymbol =
-      macCellCfg->initialUlBwp.puschCommon.startSymbol;
-   schCellCfg.schInitialUlBwp.puschCommon.lengthSymbol =
-      macCellCfg->initialUlBwp.puschCommon.lengthSymbol;
+   schCellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \
+      macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc;
+   for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++)
+   {
+      schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = 
+         macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2;
+      schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
+         macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
+      schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
+         macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
+      schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength =
+         macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength;
+   }
+
+   if(macCellCfg->plmnInfoList.snssai) 
+   {
+      schCellCfg.plmnInfoList.numSliceSupport = macCellCfg->plmnInfoList.numSupportedSlice;
+      MAC_ALLOC(schCellCfg.plmnInfoList.snssai, schCellCfg.plmnInfoList.numSliceSupport * sizeof(Snssai*));
+      if(!schCellCfg.plmnInfoList.snssai)
+      {
+         DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
+         return RFAILED;
+      }
+      for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
+      {
+         if(macCellCfg->plmnInfoList.snssai[sliceIdx])
+         {
+            MAC_ALLOC(schCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+            if(!schCellCfg.plmnInfoList.snssai[sliceIdx])
+            {
+               DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
+               return RFAILED;
+            }
+            memcpy(schCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],  sizeof(Snssai));
+         }
+      }
+   }
+
+#ifdef NR_TDD
+   memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
+#endif
 
    FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG);
 
-   ret = (*SchCellCfgOpts[cfgPst.selector])(&cfgPst, &schCellCfg);
-   return ret;
+   return(SchMessageRouter(&cfgPst, (void *)&schCellCfg));
 } /* end of MacSchCellCfgReq */
 
 
@@ -345,6 +430,10 @@ uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm)
 {
    uint16_t *cellId = NULLP;
 
+#ifdef CALL_FLOW_DEBUG_LOG
+   DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
+#endif
+
    if(schCellCfgCfm->rsp == RSP_OK)
    {
       cellId = &schCellCfgCfm->cellId;
@@ -385,6 +474,564 @@ void fapiMacConfigRsp(uint16_t cellId)
    MacSendCellCfgCfm(cellId, RSP_OK);
 }
 
+/*******************************************************************
+ *
+ * @brief Fill and Send Cell Delete response from MAC to DU APP
+ *
+ * @details
+ *
+ *    Function : MacSendCellDeleteRsp
+ *
+ *    Functionality: Fill and Send Cell Delete response from MAC to DUAPP
+ *
+ * @params[in] MAC Cell delete result
+ *             SCH Cell delete response
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId)
+{
+   MacCellDeleteRsp *deleteRsp=NULLP;
+   Pst            rspPst;
+
+   MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
+   if(!deleteRsp)
+   {
+      DU_LOG("\nERROR  -->  MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
+      return RFAILED;
+   }
+
+   /* Filling CELL delete response */
+   
+   memset(deleteRsp, 0, sizeof(MacCellDeleteRsp));
+   deleteRsp->cellId = cellId;
+   deleteRsp->result = result;
+
+   /* Fill Post structure and send CELL delete response*/
+   memset(&rspPst, 0, sizeof(Pst));
+   FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
+   return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
+}
+
+/*******************************************************************
+ *
+ * @brief  Processes CELL delete response from scheduler
+ *
+ * @details
+ *
+ *    Function : MacProcSchCellDeleteRsp
+ *
+ *    Functionality:
+ *      Processes CELL delete from scheduler
+ *
+ * @params[in] Pst : Post structure
+ *             schCellDelRsp : Scheduler CELL delete respons
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * * ****************************************************************/
+uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
+{
+   uint8_t  ret = ROK, sliceIdx = 0;
+   uint16_t cellIdx=0;
+   CellDeleteStatus status;
+   
+#ifdef CALL_FLOW_DEBUG_LOG
+   DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
+#endif  
+
+   if(schCellDelRsp)
+   {
+      if(schCellDelRsp->rsp == RSP_OK)
+      {
+         DU_LOG("\nINFO   -->  MAC : SCH CELL Delete response for cellId[%d] is successful ", \
+         schCellDelRsp->cellId);
+         GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
+         if(macCb.macCell[cellIdx])
+         {
+            if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
+            {
+               status  = SUCCESSFUL_RSP;
+               if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
+               {
+                  for(sliceIdx = 0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
+                  {
+                     MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+                  }
+                  MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.\
+                  numSupportedSlice * sizeof(Snssai*));
+               }
+               MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
+                  macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
+               MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
+            }
+            else
+            {
+                DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+                status = CELL_ID_INVALID;
+                ret = RFAILED;
+            }
+         }
+         else
+         {
+            DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+            status = CELL_ID_INVALID;
+            ret = RFAILED;
+         }
+      }
+      else
+      {
+         DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
+         status = CELL_ID_INVALID;
+         ret = RFAILED;
+      }
+      if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK)
+      {
+         DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
+         ret = RFAILED;
+      }
+
+   }
+   else
+   {
+      DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
+      ret = RFAILED;
+   }
+   return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Sends Cell delete req to Scheduler
+ *
+ * @details
+ *
+ *    Function : sendCellDelReqToSch
+ *
+ *    Functionality: sends Cell delete req to Scheduler
+ *
+ * @params[in]  SchCellDelete *schCellDel
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t sendCellDelReqToSch(SchCellDeleteReq *schCellDelReq)
+{
+   Pst schPst;
+   FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
+   return(SchMessageRouter(&schPst, (void *)schCellDelReq));
+}
+
+/*******************************************************************
+ *
+ * @brief Handles CELL Delete requst from DU APP
+ *
+ * @details
+ *
+ *    Function : MacProcCellDeleteReq
+ *
+ *    Functionality: Handles CELL Delete requst from DU APP
+ *
+ * @params[in] Pst *pst, MacCellDelete *cellDelete
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ *
+ * ****************************************************************/
+uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete)
+{
+   uint8_t ret = ROK, cellIdx=0;
+   SchCellDeleteReq schCellDelete;
+
+   DU_LOG("\nINFO   -->  MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
+
+   if(cellDelete)
+   {
+      GET_CELL_IDX(cellDelete->cellId, cellIdx);
+      if(macCb.macCell[cellIdx])
+      {
+         if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
+         {
+            memset(&schCellDelete, 0, sizeof(SchCellDeleteReq ));
+            schCellDelete.cellId =  cellDelete->cellId;
+            ret = sendCellDelReqToSch(&schCellDelete);
+            if(ret != ROK)
+            {
+               DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
+               ret = RFAILED;
+            }
+         }
+         else
+         {
+            DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+            cellDelete->cellId);
+            ret = RFAILED;
+         }
+      }
+      else
+      {
+         DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
+               cellDelete->cellId);
+         ret = RFAILED;
+      }
+
+      if(ret == RFAILED)
+      {
+          DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Sending failure response to DU");
+          if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK)
+          {
+             DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
+             cellDelete->cellId);
+          }
+
+      }
+      MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDeleteReq));
+   }
+   else
+   {
+      DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
+      ret = RFAILED;
+   }
+   return ret;
+}
+
+/**
+ * @brief free the temporary slice cfg stored in macCb.
+ *
+ * @details
+ *
+ *     Function : freeMacSliceCfgReq 
+ *
+ *   free the temporary slice cfg stored in macCb
+ *
+ *  @param[in]  
+ *  @return  int
+ *      -# ROK
+ **/
+void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst)
+{
+    uint8_t policyIdx = 0, memberListIdx=0;
+
+    if(cfgReq->numOfRrmPolicy)
+    {
+       if(cfgReq->listOfRrmPolicy)
+       {
+          for(policyIdx = 0; policyIdx<cfgReq->numOfRrmPolicy; policyIdx++)
+          {
+             if(cfgReq->listOfRrmPolicy[policyIdx])
+             {
+                if(cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem)
+                {
+                   if(cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList)
+                   {
+                      for(memberListIdx = 0; memberListIdx<cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem; memberListIdx++)
+                      {
+                         MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx], sizeof(RrmPolicyMemberList));
+                      }
+                      MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList,\
+                      cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem * sizeof(RrmPolicyMemberList*));
+                   }
+                }
+                MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx], sizeof(MacSliceRrmPolicy));
+             }
+          }
+          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy, cfgReq->numOfRrmPolicy  * sizeof(MacSliceRrmPolicy*));
+       }
+    }
+
+}
+/**
+ * @brief fill Mac Slice Config Rsp
+ *
+ * @details
+ *
+ *     Function : fillMacSliceCfgRsp 
+ *
+ *     This function   fill Mac Slice Config Rsp
+ *
+ *  @param[in]  SchSliceCfgRsp *sliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp,
+ *  uint8_t *count
+ *  @return  int
+ *      -# ROK
+ **/
+uint8_t fillMacSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp)
+{
+   
+    bool sliceFound = false;
+    uint8_t cfgIdx = 0;
+
+    macSliceCfgRsp->numSliceCfgRsp  = schSliceCfgRsp->numSliceCfgRsp;
+    MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp,  macSliceCfgRsp->numSliceCfgRsp* sizeof(MacSliceRsp*));
+    if(macSliceCfgRsp->listOfSliceCfgRsp == NULLP)
+    {
+       DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
+       return RFAILED;
+    }
+
+    for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
+    {
+       sliceFound = false;
+       if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
+       {
+          sliceFound = true;
+       }
+
+       MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
+       if(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
+       {
+          DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
+          return RFAILED;
+       }
+
+       macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai;
+       if(sliceFound == true)
+          macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_OK;
+       else
+       {
+          macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_NOK;
+          macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause  = SLICE_NOT_PRESENT;
+       }
+    }
+    return ROK;
+}
+
+/**
+ * @brief send slice cfg response to duapp.
+ *
+ * @details
+ *
+ *     Function : MacSendSliceConfigRsp
+ *
+ *   sends  slice cfg response to duapp
+ *
+ *  @param[in] MacSliceCfgRsp macSliceCfgRsp 
+ *  @return  int
+ *      -# ROK
+ **/
+uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp)
+{
+    Pst  rspPst;
+    
+    memset(&rspPst, 0, sizeof(Pst));
+    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP);
+    return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp);
+
+}
+/**
+ * @brief free the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ *     Function : freeSchSliceCfgRsp 
+ *
+ *     This free the slice cfg rsp received from sch
+ *
+ *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
+ *  @return  int
+ *      -# ROK
+ **/
+void freeSchSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp)
+{
+   uint8_t cfgIdx = 0;
+
+   if(schSliceCfgRsp)
+   {
+      if(schSliceCfgRsp->numSliceCfgRsp)
+      {
+         for(cfgIdx = 0; cfgIdx< schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
+         {
+            MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
+         }
+         MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
+      }
+   }
+}
+
+/**
+ * @brief Mac process the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ *     Function : MacProcSchSliceCfgRsp 
+ *
+ *     This function  process the slice cfg rsp received from sch
+ *
+ *  @param[in]  Pst           *pst
+ *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
+ *  @return  int
+ *      -# ROK
+ **/
+uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp)
+{
+   MacSliceCfgRsp *macSliceCfgRsp = NULLP;
+
+   if(schSliceCfgRsp)
+   {
+      MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
+      if(macSliceCfgRsp == NULLP)
+      {
+          DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
+          return RFAILED;
+      }
+      if(schSliceCfgRsp->listOfSliceCfgRsp)
+      {
+         if(fillMacSliceCfgRsp(schSliceCfgRsp, macSliceCfgRsp) != ROK)
+         {
+            DU_LOG("\nERROR  -->  MAC : Failed to fill the slice cfg response");
+            return RFAILED;
+         }
+         MacSendSliceConfigRsp(macSliceCfgRsp);
+      }
+      freeSchSliceCfgRsp(schSliceCfgRsp);
+   }
+   return ROK;
+}
+
+/**
+* @brief send slice cfg response to duapp.
+*
+* @details
+*
+*     Function : MacSendSliceReconfigRsp 
+*
+*   sends  slice cfg response to duapp
+*
+*  @param[in] MacSliceRecfgRsp macSliceRecfgRsp
+*  @return  int
+*      -# ROK
+**/
+uint8_t MacSendSliceReconfigRsp(MacSliceRecfgRsp *macSliceRecfgRsp)
+{
+   Pst  rspPst;
+
+   memset(&rspPst, 0, sizeof(Pst));
+   FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
+   return (*macDuSliceRecfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
+
+}
+
+/**
+ * @brief Mac process the slice cfg rsp received from sch.
+ *
+ * @details
+ *
+ *     Function : MacProcSchSliceRecfgRsp 
+ *
+ *     This function  process the slice cfg rsp received from sch
+ *
+ *  @param[in]  Pst           *pst
+ *  @param[in]  SchSliceCfgRsp *schSliceRecfgRsp
+ *  @return  int
+ *      -# ROK
+ **/
+uint8_t MacProcSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *schSliceRecfgRsp)
+{
+   MacSliceRecfgRsp *macSliceRecfgRsp = NULLP;
+
+   if(schSliceRecfgRsp)
+   {
+      MAC_ALLOC_SHRABL_BUF(macSliceRecfgRsp, sizeof(MacSliceRecfgRsp));
+      if(macSliceRecfgRsp == NULLP)
+      {
+          DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp");
+          return RFAILED;
+      }
+
+      if(schSliceRecfgRsp->listOfSliceCfgRsp)
+      {
+         if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceRecfgRsp) != ROK)
+         {
+            DU_LOG("\nERROR  -->  MAC : Failed to fill the slice Recfg response");
+            return RFAILED;
+         }
+         MacSendSliceReconfigRsp(macSliceRecfgRsp);
+      }
+      freeSchSliceCfgRsp(schSliceRecfgRsp);
+   }
+   return ROK;
+}
+
+/**
+ * @brief Mac process the downlink pcch indication received from DUAPP
+ *
+ * @details
+ *
+ *     Function : MacProcDlPcchInd 
+ *
+ *     This function process the downlink pcch indication received from DUAPP
+ *
+ *  @param[in]  Pst           *pst
+ *  @param[in]  DlPcchInd    *pcchInd 
+ *  @return  int
+ *      -# ROK
+ **/
+uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd)
+{
+   uint8_t ret = RFAILED;
+   uint16_t cellIdx = 0;
+   Pst       schPst;
+   SchPageInd *schPageInd = NULLP;
+
+   if(pcchInd)
+   {
+      DU_LOG("\nINFO   -->  MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId);
+      
+      GET_CELL_IDX(pcchInd->cellId, cellIdx);
+
+      if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId)
+      {
+         DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId);
+      }
+      else
+      {
+         if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0))
+         {
+            DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Pcch pdu is null");
+         }
+         else
+         {
+            MAC_ALLOC(schPageInd, sizeof(SchPageInd));
+            if(schPageInd == NULLP)
+            {
+               DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
+            }
+            else
+            {
+               schPageInd->cellId = pcchInd->cellId;
+               schPageInd->pf = pcchInd->pf;
+               schPageInd->i_s = pcchInd->i_s;
+               schPageInd->pduLen = pcchInd->pduLen;
+               
+               MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen);
+               if(schPageInd->pagePdu == NULLP)
+               {
+                  DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Failed to allocate memory");
+                  MAC_FREE(schPageInd, sizeof(SchPageInd));
+               }
+               else
+               {
+                  memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen);
+
+                  FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH);
+                  ret = SchMessageRouter(&schPst, (void *)schPageInd);
+               }
+            }
+         }
+      }
+      if((pcchInd->pcchPdu) && (pcchInd->pduLen > 0))
+      {
+         MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen);
+      }
+      MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(DlPcchInd));
+   }
+   else
+   {
+      DU_LOG("\nERROR  -->  MAC : MacProcDlPcchInd(): Received Null pointer");
+   }
+   return ret;
+}
 /**********************************************************************
   End of file
  **********************************************************************/