From: barveankit <anbarve@radisys.com>
Date: Mon, 16 May 2022 08:06:33 +0000 (+0530)
Subject: [Epic-ID: ODUHIGH-406][Task-ID: ODUHIGH-447] PCCH Scheduling at SCH
X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=o-du%2Fl2.git;a=commitdiff_plain;h=1fc18fe484bf8a324ed3ed1d04d9617869817f22

[Epic-ID: ODUHIGH-406][Task-ID: ODUHIGH-447] PCCH Scheduling at SCH

Signed-off-by: lal.harshita <Harshita.Lal@radisys.com>
Change-Id: I9f2db05f214da5b9a5c62c1db1c60c824cc84c28
Signed-off-by: lal.harshita <Harshita.Lal@radisys.com>
---

diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c
index 5f8e04948..eea67e8b1 100644
--- a/src/5gnrmac/lwr_mac_fsm.c
+++ b/src/5gnrmac/lwr_mac_fsm.c
@@ -52,7 +52,7 @@ LwrMacCb lwrMacCb;
 
 uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
 void fapiMacConfigRsp(uint16_t cellId);
-uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t prevElem);
+uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem);
 uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem);
 uint16_t fillUlDciReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem);
 uint8_t lwr_mac_procStopReqEvt(SlotTimingInfo slotInfo, p_fapi_api_queue_elem_t  prevElem);
@@ -2605,6 +2605,176 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo)
    }
 } /* fillSib1DlDciPdu */
 
+
+/*******************************************************************
+ *
+ * @brief fills Dl DCI PDU for Paging required for DL TTI info in MAC
+ *
+ * @details
+ *
+ *    Function : fillPageDlDciPdu
+ *
+ *    Functionality:
+ *         -Fills the Dl DCI PDU for Paging
+ *
+ * @params[in] Pointer to fapi_dl_dci_t
+ *             Pointer to dlPageAlloc
+ * @return ROK
+ *
+ ******************************************************************/
+
+void fillPageDlDciPdu(fapi_dl_dci_t *dlDciPtr, DlPageAlloc *dlPageAlloc)
+{
+   if(dlDciPtr != NULLP)
+   {
+      uint8_t numBytes=0;
+      uint8_t bytePos=0;
+      uint8_t bitPos=0;
+
+      uint16_t coreset0Size     = 0;
+      uint16_t rbStart          = 0;
+      uint16_t rbLen            = 0;
+      uint8_t  shortMsgInd      = 0;
+      uint8_t  shortMsg         = 0;
+      uint32_t freqDomResAssign = 0;
+      uint32_t timeDomResAssign = 0;
+      uint8_t  VRB2PRBMap       = 0;
+      uint32_t modNCodScheme    = 0;
+      uint8_t  tbScaling        = 0;
+      uint32_t reserved         = 0;
+
+      /* Size(in bits) of each field in DCI format 1_0 
+       * as mentioned in spec 38.214 */
+      uint8_t shortMsgIndSize      = 2;
+      uint8_t shortMsgSize         = 8;
+      uint8_t freqDomResAssignSize = 0;
+      uint8_t timeDomResAssignSize = 4;
+      uint8_t VRB2PRBMapSize       = 1;
+      uint8_t modNCodSchemeSize    = 5;
+      uint8_t tbScalingSize        = 2;
+      uint8_t reservedSize         = 6;
+
+      dlDciPtr->rnti = dlPageAlloc->pagePdcchCfg.dci.rnti;
+      dlDciPtr->scramblingId = dlPageAlloc->pagePdcchCfg.dci.scramblingId;    
+      dlDciPtr->scramblingRnti = dlPageAlloc->pagePdcchCfg.dci.scramblingRnti;
+      dlDciPtr->cceIndex = dlPageAlloc->pagePdcchCfg.dci.cceIndex;
+      dlDciPtr->aggregationLevel = dlPageAlloc->pagePdcchCfg.dci.aggregLevel;
+      dlDciPtr->pc_and_bform.numPrgs = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.numPrgs;
+      dlDciPtr->pc_and_bform.prgSize = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prgSize;
+      dlDciPtr->pc_and_bform.digBfInterfaces = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.digBfInterfaces;
+      dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prg[0].pmIdx;
+      dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prg[0].beamIdx[0];
+      dlDciPtr->beta_pdcch_1_0 = dlPageAlloc->pagePdcchCfg.dci.txPdcchPower.powerValue;           
+      dlDciPtr->powerControlOffsetSS = dlPageAlloc->pagePdcchCfg.dci.txPdcchPower.powerControlOffsetSS;
+
+      /* Calculating freq domain resource allocation field value and size
+       * coreset0Size = Size of coreset 0
+       * RBStart = Starting Virtual Rsource block
+       * RBLen = length of contiguously allocted RBs
+       * Spec 38.214 Sec 5.1.2.2.2
+       */
+      coreset0Size = dlPageAlloc->pagePdcchCfg.coresetCfg.coreSetSize;
+      rbStart = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
+      rbLen = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
+
+      if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
+      {
+         if((rbLen - 1) <= floor(coreset0Size / 2))
+            freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
+         else
+            freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
+                               + (coreset0Size - 1 - rbStart);
+
+         freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
+      }
+
+      /*Fetching DCI field values */
+
+      /*Refer:38.212 - Table 7.3.1.2.1-1: Short Message indicator >*/
+      if(dlPageAlloc->shortMsgInd != TRUE)
+      {
+         /*When Short Msg is absent*/
+         shortMsgInd = 1;
+         shortMsg    = 0;
+      }
+      else
+      {
+         /*Short Msg is Present*/
+         if(dlPageAlloc->dlPagePduLen == 0 || dlPageAlloc->dlPagePdu == NULLP)
+         {
+            /*When Paging Msg is absent*/
+            shortMsgInd = 2;
+         }
+         else
+         {
+            /*Both Short and Paging is present*/
+            shortMsgInd = 3;
+         }
+         shortMsg = dlPageAlloc->shortMsg;
+      }
+
+      timeDomResAssign = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+      VRB2PRBMap       = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
+      modNCodScheme    = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->codeword[0].mcsIndex;
+      tbScaling        = 0;
+      reserved         = 0;
+
+      /* Reversing bits in each DCI field */
+      shortMsgInd      = reverseBits(shortMsgInd, shortMsgIndSize);
+      shortMsg         = reverseBits(shortMsg, shortMsgSize);
+      timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
+      freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
+      timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
+      VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
+      modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
+      tbScaling        = reverseBits(tbScaling, tbScalingSize); 
+
+      /* Calulating total number of bytes in buffer */
+      dlDciPtr->payloadSizeBits = shortMsgIndSize + shortMsgSize + freqDomResAssignSize\
+                                  + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
+                                  + tbScaling + reservedSize;
+
+      numBytes = dlDciPtr->payloadSizeBits / 8;
+      if(dlDciPtr->payloadSizeBits % 8)
+      {
+         numBytes += 1;
+      }
+
+      if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
+      {
+         DU_LOG("\nERROR  -->  LWR_MAC : Total bytes for DCI is more than expected");
+         return;
+      }
+
+      /* Initialize buffer */
+      for(bytePos = 0; bytePos < numBytes; bytePos++)
+      {
+         dlDciPtr->payload[bytePos] = 0;
+      }
+
+      bytePos = numBytes - 1;
+      bitPos = 0;
+
+      /* Packing DCI format fields */
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            shortMsgInd, shortMsgIndSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            shortMsg, shortMsgSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            freqDomResAssign, freqDomResAssignSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            timeDomResAssign, timeDomResAssignSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            VRB2PRBMap, VRB2PRBMapSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            modNCodScheme, modNCodSchemeSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            tbScaling, tbScalingSize);
+      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+            reserved, reservedSize);
+   }
+} /* fillPageDlDciPdu */
+
 /*******************************************************************
  *
  * @brief fills Dl DCI PDU required for DL TTI info in MAC
@@ -2922,7 +3092,7 @@ void fillDlMsgDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *pdcchInfo,\
  * @return ROK
  *
  ******************************************************************/
-uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, int8_t dlMsgSchInfoIdx, \
+uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacDlSlot *dlSlot, int8_t dlMsgSchInfoIdx, \
       RntiType rntiType, uint8_t coreSetType, uint8_t ueIdx)
 {
    if(dlTtiReqPdu != NULLP)
@@ -2933,22 +3103,28 @@ uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, in
       memset(&dlTtiReqPdu->pdu.pdcch_pdu, 0, sizeof(fapi_dl_pdcch_pdu_t));
       if(rntiType == SI_RNTI_TYPE)
       {
-         pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
-         bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
+         pdcchInfo = &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg;
+         bwp = &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp;
          fillSib1DlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
       }
+      else if(rntiType == P_RNTI_TYPE)
+      {
+         pdcchInfo = &dlSlot->pageAllocInfo->pagePdcchCfg;
+         bwp = &dlSlot->pageAllocInfo->bwp;
+         fillPageDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, dlSlot->pageAllocInfo);
+      }
       else if(rntiType == RA_RNTI_TYPE)
       {
-         pdcchInfo = &dlInfo->rarAlloc[ueIdx]->rarPdcchCfg;
-         bwp = &dlInfo->rarAlloc[ueIdx]->bwp;
+         pdcchInfo = &dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg;
+         bwp = &dlSlot->dlInfo.rarAlloc[ueIdx]->bwp;
          fillRarDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
       }
       else if(rntiType == TC_RNTI_TYPE || rntiType == C_RNTI_TYPE)
       {
-         pdcchInfo = &dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgPdcchCfg;
-         bwp = &dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].bwp;
+         pdcchInfo = &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgPdcchCfg;
+         bwp = &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].bwp;
          fillDlMsgDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo,\
-               &dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgInfo);
+               &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgInfo);
       }
       else
       {
@@ -3016,12 +3192,12 @@ void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
       dlTtiReqPdu->pdu.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
       for(idx = 0; idx < MAX_CODEWORDS ; idx++)
       { 
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
-	 dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
+         dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
       }
       dlTtiReqPdu->pdu.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;       
       dlTtiReqPdu->pdu.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
@@ -3044,9 +3220,9 @@ void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
       dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
       dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
       dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
-	 pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
+         pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
       dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
-	 beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
+         beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
       dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;  
       dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
       dlTtiReqPdu->pdu.pdsch_pdu.mappingType =   pdschInfo->dmrs.mappingType;
@@ -3068,52 +3244,58 @@ void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
  *    Functionality:
  *         -calculates the total pdu count to be allocated for DL TTI Req
  *
- * @params[in]    DlBrdcstAlloc *cellBroadcastInfo
+ * @params[in]   MacDlSlot *dlSlot 
  * @return count
  *
  * ********************************************************************/
-uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
+uint8_t calcDlTtiReqPduCount(MacDlSlot *dlSlot)
 {
    uint8_t count = 0;
    uint8_t idx = 0, ueIdx=0;
 
-   if(dlInfo->isBroadcastPres)
+   if(dlSlot->dlInfo.isBroadcastPres)
    {
-      if(dlInfo->brdcstAlloc.ssbTrans)
+      if(dlSlot->dlInfo.brdcstAlloc.ssbTrans)
       {
-         for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
+         for(idx = 0; idx < dlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
          {
             /* SSB PDU is filled */
             count++;
          }
       }
-      if(dlInfo->brdcstAlloc.sib1Trans)
+      if(dlSlot->dlInfo.brdcstAlloc.sib1Trans)
       {
          /* PDCCH and PDSCH PDU is filled */
          count += 2;
       }
    }
 
+   if(dlSlot->pageAllocInfo)
+   {
+      /* PDCCH and PDSCH PDU is filled */
+      count += 2;
+   }
+
    for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
    {
-      if(dlInfo->rarAlloc[ueIdx] != NULLP)
+      if(dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
       {
          /* PDCCH and PDSCH PDU is filled */
-         if(dlInfo->rarAlloc[ueIdx]->pduPres == BOTH)
+         if(dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH)
             count += 2;
          else
             count += 1;
       }
 
-      if(dlInfo->dlMsgAlloc[ueIdx] != NULLP)
+      if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
       {
-         for(idx=0; idx<dlInfo->dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
+         for(idx=0; idx<dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
          {
-         /* PDCCH and PDSCH PDU is filled */
-         if(dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH)
-            count += 2;
-         else if(dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres != NONE)
-            count += 1;
+            /* PDCCH and PDSCH PDU is filled */
+            if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH)
+               count += 2;
+            else if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres != NONE)
+               count += 1;
          }
       }
    }
@@ -3135,27 +3317,31 @@ uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
  * @return count
  *
  * ********************************************************************/
-uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
+uint8_t calcTxDataReqPduCount(MacDlSlot *dlSlot)
 {
    uint8_t idx = 0, count = 0, ueIdx=0;
 
-   if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
+   if(dlSlot->dlInfo.isBroadcastPres && dlSlot->dlInfo.brdcstAlloc.sib1Trans)
    {
       count++;
    }
-   
+   if(dlSlot->pageAllocInfo)
+   {
+      count++;
+   }
+
    for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
    {
-      if((dlInfo->rarAlloc[ueIdx] != NULLP) && \
-            ((dlInfo->rarAlloc[ueIdx]->pduPres == BOTH) || (dlInfo->rarAlloc[ueIdx]->pduPres == PDSCH_PDU)))
+      if((dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP) && \
+            ((dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || (dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDSCH_PDU)))
          count++;
 
-      if(dlInfo->dlMsgAlloc[ueIdx] != NULLP)
+      if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
       {
-         for(idx=0; idx<dlInfo->dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
+         for(idx=0; idx<dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
          {
-            if(dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH || \
-                  dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == PDSCH_PDU)
+            if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH || \
+                  dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == PDSCH_PDU)
                count++;
          }
       }
@@ -3225,6 +3411,68 @@ uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, MacCel
    return ROK;
 }
 
+/***********************************************************************
+ *
+ * @brief fills the PAGE TX-DATA request message
+ *
+ * @details
+ *
+ *    Function : fillPageTxDataReq
+ *
+ *    Functionality:
+ *         - fills the Page TX-DATA request message
+ *
+ * @params[in]    fapi_tx_pdu_desc_t *pduDesc
+ * @params[in]    macCellCfg consist of SIB1 pdu
+ * @params[in]    uint32_t *msgLen
+ * @params[in]    uint16_t pduIndex
+ * @return ROK
+ *
+ * ********************************************************************/
+uint8_t fillPageTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlPageAlloc *pageAllocInfo,
+                           PdschCfg pdschCfg)
+{
+   uint32_t payloadSize = 0;
+   uint8_t *pagePayload = NULLP;
+   fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+   void * wlsHdlr = NULLP;
+#endif
+
+   pduDesc[pduIndex].pdu_index = pduIndex;
+   pduDesc[pduIndex].num_tlvs = 1;
+
+   /* fill the TLV */
+   payloadSize = pdschCfg.codeword[0].tbSize;
+   pduDesc[pduIndex].tlvs[0].tl.tag = ((payloadSize & 0xff0000) >> 8) | FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+   pduDesc[pduIndex].tlvs[0].tl.length = (payloadSize & 0x0000ffff);
+   LWR_MAC_ALLOC(pagePayload, payloadSize);
+   if(pagePayload == NULLP)
+   {
+      return RFAILED;
+   }
+   payloadElem = (fapi_api_queue_elem_t *)pagePayload;
+   FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \
+         pageAllocInfo->dlPagePduLen);
+   memcpy(pagePayload + TX_PAYLOAD_HDR_LEN, pageAllocInfo->dlPagePdu, pageAllocInfo->dlPagePduLen);
+
+#ifdef INTEL_WLS_MEM
+   mtGetWlsHdl(&wlsHdlr);
+   pduDesc[pduIndex].tlvs[0].value = WLS_VA2PA(wlsHdlr, pagePayload);
+#else
+   pduDesc[pduIndex].tlvs[0].value = pagePayload;
+#endif
+   pduDesc[pduIndex].pdu_length = payloadSize; 
+
+#ifdef INTEL_WLS_MEM   
+   addWlsBlockToFree(pagePayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+   LWR_MAC_FREE(pagePayload, payloadSize);
+#endif
+
+   return ROK;
+}
+
 /***********************************************************************
  *
  * @brief fills the RAR TX-DATA request message
@@ -3423,7 +3671,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
 
          dlTtiReq->sfn  = dlTtiReqTimingInfo.sfn;
          dlTtiReq->slot = dlTtiReqTimingInfo.slot;
-         dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo);  /* get total Pdus */
+         dlTtiReq->nPdus = calcDlTtiReqPduCount(currDlSlot);  /* get total Pdus */
          nPdu = dlTtiReq->nPdus;
          dlTtiReq->nGroup = 0;
          if(dlTtiReq->nPdus > 0)
@@ -3452,7 +3700,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
                   if(numPduEncoded != nPdu)
                   {
                      rntiType = SI_RNTI_TYPE;
-                     fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo, -1, \
+                     fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], currDlSlot, -1, \
                            rntiType, CORESET_TYPE0, MAX_NUM_UE);
                      numPduEncoded++;
                      fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
@@ -3468,7 +3716,29 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
                   DU_LOG("\033[0m");
                }
             }
-            
+
+            if(currDlSlot->pageAllocInfo != NULLP)
+            {
+               /* Filling DL Paging Alloc param */
+               if(numPduEncoded != nPdu)
+               {
+                  rntiType = P_RNTI_TYPE;
+                  fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], currDlSlot, -1, \
+                        rntiType, CORESET_TYPE0, MAX_NUM_UE);
+                  numPduEncoded++;
+                  fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+                        &currDlSlot->pageAllocInfo->pagePdschCfg,
+                        currDlSlot->pageAllocInfo->bwp,
+                        pduIndex);
+                  dlTtiReq->ue_grp_info[dlTtiReq->nGroup].pduIdx[pduIndex] = pduIndex;
+                  pduIndex++;
+                  numPduEncoded++;
+               }
+               DU_LOG("\033[1;34m");
+               DU_LOG("\nDEBUG  -->  LWR_MAC: PAGE sent...");
+               DU_LOG("\033[0m");
+            }
+
             for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
             {
                if(currDlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
@@ -3479,7 +3749,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
                         (currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDCCH_PDU))
                   {
                      fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
-                           &currDlSlot->dlInfo, -1, rntiType, CORESET_TYPE0, ueIdx);
+                           currDlSlot, -1, rntiType, CORESET_TYPE0, ueIdx);
                      numPduEncoded++;
                   }
                   if((currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || \
@@ -3510,14 +3780,14 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
                         {
                            rntiType = TC_RNTI_TYPE;
                            fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
-                                 &currDlSlot->dlInfo, idx, rntiType, CORESET_TYPE0, ueIdx);
+                                 currDlSlot, idx, rntiType, CORESET_TYPE0, ueIdx);
                         }
                         else
                         { 
                            /* Filling other DL msg params */
                            rntiType = C_RNTI_TYPE;
                            fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
-                                 &currDlSlot->dlInfo, idx, rntiType, CORESET_TYPE1, ueIdx);
+                                 currDlSlot, idx, rntiType, CORESET_TYPE1, ueIdx);
                         }
                         numPduEncoded++;
                      }
@@ -3546,12 +3816,12 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
                         }
 
                      }
-                  /*   else
-                     {
-                        MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
-                        currDlSlot->dlInfo.dlMsgAlloc[ueIdx] = NULLP;
-                     }
-                     */
+                     /*   else
+                          {
+                          MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
+                          currDlSlot->dlInfo.dlMsgAlloc[ueIdx] = NULLP;
+                          }
+                          */
                   }
                }
             }
@@ -3572,7 +3842,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
             msgHeader->num_msg++;
 
             /* send Tx-DATA req message */
-            sendTxDataReq(dlTtiReqTimingInfo, &currDlSlot->dlInfo, dlTtiElem->p_next->p_next);
+            sendTxDataReq(dlTtiReqTimingInfo, currDlSlot, dlTtiElem->p_next->p_next);
             if(dlTtiElem->p_next->p_next->p_next)
             {
                msgHeader->num_msg++;
@@ -3641,7 +3911,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
  *         RFAILED - failure
  *
  * ****************************************************************/
-uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t prevElem)
+uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem)
 {
 #ifdef INTEL_FAPI
 #ifdef CALL_FLOW_DEBUG_LOG
@@ -3659,7 +3929,7 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, DlSchedInfo *dlInfo, p_fap
    GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
 
    /* send TX_Data request message */
-   nPdu = calcTxDataReqPduCount(dlInfo);
+   nPdu = calcTxDataReqPduCount(dlSlot);
    if(nPdu > 0)
    {
       LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
@@ -3677,46 +3947,55 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, DlSchedInfo *dlInfo, p_fap
 
       txDataReq->sfn  = currTimingInfo.sfn;
       txDataReq->slot = currTimingInfo.slot;
-      if(dlInfo->brdcstAlloc.sib1Trans)
+      if(dlSlot->dlInfo.brdcstAlloc.sib1Trans)
       {
          fillSib1TxDataReq(txDataReq->pdu_desc, pduIndex, &macCb.macCell[cellIdx]->macCellCfg, \
-               dlInfo->brdcstAlloc.sib1Alloc.sib1PdschCfg);
+               dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg);
+         pduIndex++;
+         txDataReq->num_pdus++;
+      }
+      if(dlSlot->pageAllocInfo != NULLP)
+      {
+         fillPageTxDataReq(txDataReq->pdu_desc, pduIndex, dlSlot->pageAllocInfo, \
+               dlSlot->pageAllocInfo->pagePdschCfg);
          pduIndex++;
          txDataReq->num_pdus++;
+         MAC_FREE(dlSlot->pageAllocInfo->dlPagePdu, sizeof(dlSlot->pageAllocInfo->dlPagePduLen));
+         MAC_FREE(dlSlot->pageAllocInfo,sizeof(DlPageAlloc));
       }
 
       for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
       {
-         if(dlInfo->rarAlloc[ueIdx] != NULLP)
+         if(dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
          {
-            if((dlInfo->rarAlloc[ueIdx]->pduPres == BOTH) || (dlInfo->rarAlloc[ueIdx]->pduPres == PDSCH_PDU))
+            if((dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || (dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDSCH_PDU))
             {
-               fillRarTxDataReq(txDataReq->pdu_desc, pduIndex, &dlInfo->rarAlloc[ueIdx]->rarInfo,\
-                     dlInfo->rarAlloc[ueIdx]->rarPdschCfg);
+               fillRarTxDataReq(txDataReq->pdu_desc, pduIndex, &dlSlot->dlInfo.rarAlloc[ueIdx]->rarInfo,\
+                     dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg);
                pduIndex++;
                txDataReq->num_pdus++;
             }
-            MAC_FREE(dlInfo->rarAlloc[ueIdx],sizeof(RarAlloc));
+            MAC_FREE(dlSlot->dlInfo.rarAlloc[ueIdx],sizeof(RarAlloc));
          }
 
-         if(dlInfo->dlMsgAlloc[ueIdx] != NULLP)
+         if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
          {
-            for(schInfoIdx=0; schInfoIdx < dlInfo->dlMsgAlloc[ueIdx]->numSchedInfo; schInfoIdx++)
+            for(schInfoIdx=0; schInfoIdx < dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; schInfoIdx++)
             {
-               if((dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == BOTH) || \
-                     (dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU))
+               if((dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == BOTH) || \
+                     (dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU))
                {
                   fillDlMsgTxDataReq(txDataReq->pdu_desc, pduIndex, \
-                        &dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo, \
-                        dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgPdschCfg);
+                        &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo, \
+                        dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgPdschCfg);
                   pduIndex++;
                   txDataReq->num_pdus++;
                }
-               MAC_FREE(dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu, \
-                     dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPduLen);
-               dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu = NULLP;
+               MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu, \
+                     dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPduLen);
+               dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu = NULLP;
             }
-            MAC_FREE(dlInfo->dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
+            MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
          }
       }
 
diff --git a/src/5gnrmac/lwr_mac_fsm.h b/src/5gnrmac/lwr_mac_fsm.h
index 823445574..3b137826a 100644
--- a/src/5gnrmac/lwr_mac_fsm.h
+++ b/src/5gnrmac/lwr_mac_fsm.h
@@ -48,7 +48,8 @@ typedef enum{
    SI_RNTI_TYPE,
    RA_RNTI_TYPE,
    TC_RNTI_TYPE,
-   C_RNTI_TYPE
+   C_RNTI_TYPE,
+   P_RNTI_TYPE
 }RntiType;
 
 uint8_t lwr_mac_procInvalidEvt(void *msg);
diff --git a/src/5gnrmac/mac.h b/src/5gnrmac/mac.h
index cf9e4e13d..fb78f8073 100644
--- a/src/5gnrmac/mac.h
+++ b/src/5gnrmac/mac.h
@@ -93,6 +93,7 @@ typedef enum
 typedef struct macDlSlot
 {
    DlSchedInfo dlInfo;
+   DlPageAlloc *pageAllocInfo;
 }MacDlSlot;
 
 typedef struct macUlSlot
diff --git a/src/5gnrmac/mac_cfg_hdl.c b/src/5gnrmac/mac_cfg_hdl.c
index fae023324..c5f7f027a 100644
--- a/src/5gnrmac/mac_cfg_hdl.c
+++ b/src/5gnrmac/mac_cfg_hdl.c
@@ -1025,7 +1025,6 @@ uint8_t MacProcDlPcchInd(Pst *pst, MacPcchInd *pcchInd)
                {
                   memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen);
 
-                  DU_LOG("\nINFO -->  MAC : Sending paging indication to SCH");
                   FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH);
                   ret = (*macSchPagingIndOpts[schPst.selector])(&schPst, schPageInd);
                }
diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c
index 3a3d008d7..321e3500b 100644
--- a/src/5gnrmac/mac_slot_ind.c
+++ b/src/5gnrmac/mac_slot_ind.c
@@ -126,7 +126,53 @@ uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo)
 }
 
 /**
- * @brief Forming anf filling the MUX Pdu
+ * @brief process DL Paging allocation from scheduler
+ *
+ * @details
+ *
+ *     Function : MacProcDlPageAlloc 
+ *      
+ *      This function copied dl Pag info in the mac slot info
+ *           
+ *  @param[in]  Pst            *pst
+ *  @param[in]  DL Paging allocation from scheduler
+ *  @return
+ *      -# ROK 
+ *      -# RFAILED 
+ **/
+uint8_t MacProcDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc)
+{
+   uint16_t  cellIdx = 0;
+   MacDlSlot *currDlSlot = NULLP;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+   DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_PAGING_ALLOC\n");
+#endif
+   if(dlPageAlloc != NULLP)
+   {
+      GET_CELL_IDX(dlPageAlloc->cellId, cellIdx);
+
+      currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlPageAlloc->dlPageTime.slot];
+      MAC_ALLOC(currDlSlot->pageAllocInfo, sizeof(DlPageAlloc));
+      if(currDlSlot->pageAllocInfo == NULLP)
+      {
+         DU_LOG("\nERROR  --> MAC : MacProcDlPageAlloc : Memory Allocation is failed!");
+         return RFAILED;
+      }
+      memcpy(currDlSlot->pageAllocInfo, dlPageAlloc, sizeof(DlPageAlloc));
+      currDlSlot->pageAllocInfo->pagePdcchCfg.dci.pdschCfg = \
+                                                             &currDlSlot->pageAllocInfo->pagePdschCfg;
+   }
+   else
+   {
+      DU_LOG("\nERROR  --> MAC : DL Paging Allocation is failed!");
+      return RFAILED;
+   }
+   return ROK;
+}
+
+/**
+ * @brief Forming and filling the MUX Pdu
  * @details
  *
  *     Function : fillMsg4Pdu
diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c
index 15d4dfd08..aed0a81bd 100644
--- a/src/5gnrsch/sch.c
+++ b/src/5gnrsch/sch.c
@@ -2138,14 +2138,14 @@ uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo)
    while(firstNodeOfList)
    {
       tempNode = (SchPageInfo*)(firstNodeOfList->node);
-      if ((recvdNode->TxTime.slot < tempNode->TxTime.slot))
+      if ((recvdNode->pageTxTime.slot < tempNode->pageTxTime.slot))
       {
          cmLListInsCrnt(storedPageList, currentNodeInfo);
          break;
       }
-      else if ((recvdNode->TxTime.slot == tempNode->TxTime.slot))
+      else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot))
       {
-         DU_LOG("\nERROR  --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->TxTime.slot);
+         DU_LOG("\nERROR  --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot);
          return RFAILED;
       }
       else
@@ -2187,7 +2187,8 @@ uint8_t MacSchPagingInd(Pst *pst,  SchPageInd *pageInd)
 
    if(pageInd)
    {
-      DU_LOG("\nINFO  --> SCH : Received paging indication form MAC for cellId[%d]",pageInd->cellId);
+      DU_LOG("\nINFO   --> SCH : Received paging indication form MAC for cellId[%d]",\
+                  pageInd->cellId);
 
       /* Fetch Cell CB */
       for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
@@ -2211,9 +2212,9 @@ uint8_t MacSchPagingInd(Pst *pst,  SchPageInd *pageInd)
             {
                pageInfo->pf = pageInd->pf; 
                pageInfo->i_s = pageInd->i_s;
-               pageInfo->TxTime.cellId = pageInd->cellId;
-               pageInfo->TxTime.sfn = (pageInd->pf +  cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN;
-               pageInfo->TxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot;
+               pageInfo->pageTxTime.cellId = pageInd->cellId;
+               pageInfo->pageTxTime.sfn = (pageInd->pf +  cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN;
+               pageInfo->pageTxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot;
                pageInfo->mcs = DEFAULT_MCS;
                pageInfo->msgLen =  pageInd->pduLen;
                SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen);
@@ -2224,7 +2225,7 @@ uint8_t MacSchPagingInd(Pst *pst,  SchPageInd *pageInd)
                else
                {
                   memcpy(pageInfo->pagePdu, pageInd->pagePdu, pageInfo->msgLen);
-                  ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->TxTime.sfn], pageInfo);
+                  ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo);
                   if(ret != ROK)
                   {
                      DU_LOG("\nERROR  --> SCH : MacSchPagingInd(): Failed to store paging record");
diff --git a/src/5gnrsch/sch.h b/src/5gnrsch/sch.h
index 38d1dd9db..3793761f5 100644
--- a/src/5gnrsch/sch.h
+++ b/src/5gnrsch/sch.h
@@ -294,14 +294,12 @@ typedef struct schRaReq
 
 typedef struct schPageInfo
 {
-  uint16_t       pf;       /*Value of Paging Frame received from DUAPP*/
-  uint8_t        i_s;      /*Value of Paging Occ Index received from DUAPP*/
-  SlotTimingInfo TxTime;   /*Start Paging window*/
-  uint8_t        crntSsbIdx; /*Counts the slot till totalSSB is receached*/
-  uint8_t        mcs;
-  uint8_t        nPRB;
-  uint16_t       msgLen;
-  uint8_t        *pagePdu;   
+  uint16_t       pf;          /*Value of Paging Frame received from DUAPP*/
+  uint8_t        i_s;         /*Value of Paging Occ Index received from DUAPP*/
+  SlotTimingInfo pageTxTime;  /*Start Paging window*/
+  uint8_t        mcs;         /*MCS index*/
+  uint16_t       msgLen;      /*Pdu length */
+  uint8_t       *pagePdu;     /*RRC Page PDU bit string*/
 }SchPageInfo;
 
 typedef struct schPagingOcc
@@ -312,9 +310,8 @@ typedef struct schPagingOcc
 
 typedef struct schPageCb
 {
-   CmLListCp    pageIndInfoRecord[MAX_SFN];   /*List of Page Records received which are stored per sfn*/
-   SchPagingOcc pagMonOcc[MAX_PO_PER_PF]; /*Paging Occasion Slot/FrameOffset are stored*/ 
-   SchPageInfo  currPageInfo;   /*Page Req which is being currently processed */
+   CmLListCp    pageIndInfoRecord[MAX_SFN]; /*List of Page Records received which are stored per sfn*/
+   SchPagingOcc pagMonOcc[MAX_PO_PER_PF];   /*Paging Occasion Slot/FrameOffset are stored*/ 
 }SchPageCb;
 
 /**
@@ -437,6 +434,8 @@ void updateBsrAndLcList(CmLListCp *lcLL, BsrInfo *bsrInfo, uint8_t status);
 void schProcPagingCfg(SchCellCb *cell);
 void schCfgPdcchMonOccOfPO(SchCellCb *cell);
 void schIncrSlot(SlotTimingInfo *timingInfo, uint8_t incr, uint16_t numSlotsPerRF);
+uint8_t schFillPagePdschCfg(SchCellCb *cell, PdschCfg *pagePdschCfg, SlotTimingInfo slotTime, \
+                             uint16_t tbSize, uint8_t mcs, uint16_t startPrb);
 
 /**********************************************************************
   End of file
diff --git a/src/5gnrsch/sch_common.c b/src/5gnrsch/sch_common.c
index 2d0370202..23b648bd6 100644
--- a/src/5gnrsch/sch_common.c
+++ b/src/5gnrsch/sch_common.c
@@ -2133,6 +2133,103 @@ void schIncrSlot(SlotTimingInfo *timingInfo, uint8_t incr, uint16_t numSlotsPerR
       }
    }
 }
+
+/*******************************************************************
+*
+* @brief   Fill PDSCH info in Page Alloc
+*
+* @details
+*
+*    Function : schFillPagePdschCfg 
+*
+*    Functionality: Fill PDSCH info in Page Alloc
+*
+* @params[in] SchCellCb *cell, PdschCfg *pagePdschCfg, SlotTimingInfo slotTime, 
+*             uint16_t tbsSize, uint8_t mcs, uint16_t startPrb
+*
+* @return pointer to return Value(ROK, RFAILED) 
+*
+* ****************************************************************/
+uint8_t schFillPagePdschCfg(SchCellCb *cell, PdschCfg *pagePdschCfg, SlotTimingInfo slotTime, uint16_t tbSize, uint8_t mcs, uint16_t startPrb)
+{
+   uint8_t cwCount = 0;
+   uint8_t dmrsStartSymbol, startSymbol, numSymbol;
+
+   /* fill the PDSCH PDU */
+
+   pagePdschCfg->pduBitmap = 0; /* PTRS and CBG params are excluded */
+   pagePdschCfg->rnti = P_RNTI; /* SI-RNTI */
+   pagePdschCfg->pduIndex = 0;
+   pagePdschCfg->numCodewords = 1;
+   for(cwCount = 0; cwCount < pagePdschCfg->numCodewords; cwCount++)
+   {
+      pagePdschCfg->codeword[cwCount].targetCodeRate = 308;
+      pagePdschCfg->codeword[cwCount].qamModOrder = 2;
+      pagePdschCfg->codeword[cwCount].mcsIndex = mcs;
+      pagePdschCfg->codeword[cwCount].mcsTable = 0; /* notqam256 */
+      pagePdschCfg->codeword[cwCount].rvIndex = 0;
+      tbSize = tbSize + TX_PAYLOAD_HDR_LEN;
+      pagePdschCfg->codeword[cwCount].tbSize = tbSize;
+   }
+   pagePdschCfg->dataScramblingId                   = cell->cellCfg.phyCellId;
+   pagePdschCfg->numLayers                          = 1;
+   pagePdschCfg->transmissionScheme                 = 0;
+   pagePdschCfg->refPoint                           = 0;
+   pagePdschCfg->dmrs.dlDmrsSymbPos                 = 4; /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
+   pagePdschCfg->dmrs.dmrsConfigType                = 0; /* type-1 */
+   pagePdschCfg->dmrs.dlDmrsScramblingId            = cell->cellCfg.phyCellId;
+   pagePdschCfg->dmrs.scid                          = 0;
+   pagePdschCfg->dmrs.numDmrsCdmGrpsNoData          = 1;
+   pagePdschCfg->dmrs.dmrsPorts                     = 0x0001;
+   pagePdschCfg->dmrs.mappingType                   = DMRS_MAP_TYPE_A; /* Type-A */
+   pagePdschCfg->dmrs.nrOfDmrsSymbols               = NUM_DMRS_SYMBOLS;
+   pagePdschCfg->dmrs.dmrsAddPos                    = DMRS_ADDITIONAL_POS;
+
+   pagePdschCfg->pdschFreqAlloc.resourceAllocType   = 1; /* RAT type-1 RIV format */
+   /* the RB numbering starts from coreset0, and PDSCH is always above SSB */
+   pagePdschCfg->pdschFreqAlloc.freqAlloc.startPrb  = startPrb;
+   pagePdschCfg->pdschFreqAlloc.freqAlloc.numPrb    = schCalcNumPrb(tbSize, mcs, NUM_PDSCH_SYMBOL);
+   pagePdschCfg->pdschFreqAlloc.vrbPrbMapping       = 0; /* non-interleaved */
+   pagePdschCfg->pdschTimeAlloc.rowIndex            = 1;
+   /* This is Intel's requirement. PDSCH should start after PDSCH DRMS symbol */
+   pagePdschCfg->pdschTimeAlloc.timeAlloc.startSymb = 3; /* spec-38.214, Table 5.1.2.1-1 */
+   pagePdschCfg->pdschTimeAlloc.timeAlloc.numSymb   = NUM_PDSCH_SYMBOL;
+
+   /* Find total symbols occupied including DMRS */
+   dmrsStartSymbol = findDmrsStartSymbol(pagePdschCfg->dmrs.dlDmrsSymbPos);
+   /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT,
+    * in that case only PDSCH symbols are marked as occupied */
+   if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
+   {
+      startSymbol = pagePdschCfg->pdschTimeAlloc.timeAlloc.startSymb;
+      numSymbol = pagePdschCfg->pdschTimeAlloc.timeAlloc.numSymb;
+   }
+   /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
+   else
+   {
+      startSymbol = dmrsStartSymbol;
+      numSymbol = pagePdschCfg->dmrs.nrOfDmrsSymbols + pagePdschCfg->pdschTimeAlloc.timeAlloc.numSymb;
+   }
+
+   /* Allocate the number of PRBs required for DL PDSCH */
+   if((allocatePrbDl(cell, slotTime, startSymbol, numSymbol,\
+               &pagePdschCfg->pdschFreqAlloc.freqAlloc.startPrb, pagePdschCfg->pdschFreqAlloc.freqAlloc.numPrb)) != ROK)
+   {
+      DU_LOG("\nERROR  --> SCH : allocatePrbDl() failed for DL MSG");
+      return RFAILED;
+   }
+
+   pagePdschCfg->beamPdschInfo.numPrgs              = 1;
+   pagePdschCfg->beamPdschInfo.prgSize              = 1;
+   pagePdschCfg->beamPdschInfo.digBfInterfaces      = 0;
+   pagePdschCfg->beamPdschInfo.prg[0].pmIdx         = 0;
+   pagePdschCfg->beamPdschInfo.prg[0].beamIdx[0]    = 0;
+   pagePdschCfg->txPdschPower.powerControlOffset    = 0;
+   pagePdschCfg->txPdschPower.powerControlOffsetSS  = 0;
+
+   return ROK;
+}
+
 /**********************************************************************
   End of file
  **********************************************************************/
diff --git a/src/5gnrsch/sch_slot_ind.c b/src/5gnrsch/sch_slot_ind.c
index 920562d63..dcebee162 100644
--- a/src/5gnrsch/sch_slot_ind.c
+++ b/src/5gnrsch/sch_slot_ind.c
@@ -49,6 +49,13 @@ SchMacDlAllocFunc schMacDlAllocOpts[] =
    packSchMacDlAlloc
 };
 
+SchMacDlPageAllocFunc schMacDlPageAllocOpts[] =
+{
+   packSchMacDlPageAlloc,
+   MacProcDlPageAlloc,
+   packSchMacDlPageAlloc
+};
+
 /*******************************************************************
  *
  * @brief Handles sending DL broadcast alloc to MAC 
@@ -77,6 +84,34 @@ uint8_t sendDlAllocToMac(DlSchedInfo *dlSchedInfo, Inst inst)
 
 }
 
+/*******************************************************************
+ *
+ * @brief Handles sending DL Page alloc to MAC 
+ *
+ * @details
+ *
+ *    Function : sendDlPAgeAllocToMac
+ *
+ *    Functionality:
+ *     Sends DL Page Resource Allocation to MAC from SCH
+ *
+ * @params[in] 
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t sendDlPageAllocToMac(DlPageAlloc *dlPageAlloc, Inst inst)
+{
+   Pst pst;
+
+   memset(&pst, 0, sizeof(Pst));
+   FILL_PST_SCH_TO_MAC(pst, inst);
+   pst.event = EVENT_DL_PAGING_ALLOC;
+
+   return(*schMacDlPageAllocOpts[pst.selector])(&pst, dlPageAlloc);
+
+}
+
 /*******************************************************************
  *
  * @brief Handles slot indication at SCH 
@@ -572,6 +607,107 @@ bool schFillBoGrantDlSchedInfo(SchCellCb *cell, SlotTimingInfo currTime, uint8_t
    return true;
 }
 
+/*******************************************************************
+*
+* @brief Process DL Resource allocation for Page
+*
+* @details
+*
+*    Function : schProcDlPageAlloc
+*
+*    Functionality: Process DL Resource allocation for Page
+*
+* @params[in] SchCellCb *cell, SlotTimingInfo currTime, Inst schInst
+*
+* @return pointer to return Value(ROK, RFAILED)
+*
+* ****************************************************************/
+uint8_t schProcDlPageAlloc(SchCellCb *cell, SlotTimingInfo currTime, Inst schInst)
+{
+   DlPageAlloc      dlPageAlloc;
+   CmLList          *pageInfoNode = NULLP;
+   SchPageInfo      *pageInfo = NULLP;
+   SlotTimingInfo   pdschTime;
+   uint32_t         tbSize = 0;
+   uint16_t         startPrb = 0, maxFreePRB = 0, nPRB = 0;
+   uint8_t          ret = RFAILED;
+
+   pageInfoNode = schPageInfoSearchFromPageList(currTime, &(cell->pageCb.pageIndInfoRecord[currTime.sfn]));
+
+   if(pageInfoNode == NULLP)
+   {
+      return ROK;
+   }
+   pageInfo = (SchPageInfo *)pageInfoNode->node;
+   
+   while(true)
+   {
+      dlPageAlloc.cellId = currTime.cellId;
+
+      ADD_DELTA_TO_TIME(currTime, dlPageAlloc.dlPageTime, PHY_DELTA_DL + SCHED_DELTA);
+      dlPageAlloc.shortMsgInd  = FALSE;
+      pdschTime = dlPageAlloc.dlPageTime;
+
+      /*Calculate Best FREE BLOCK with MAX PRB count*/
+      maxFreePRB = searchLargestFreeBlock(cell, pdschTime, &startPrb, DIR_DL);
+
+      if(maxFreePRB != 0)
+      {
+         tbSize = calculateEstimateTBSize(pageInfo->msgLen, pageInfo->mcs, NUM_PDSCH_SYMBOL, maxFreePRB, &nPRB);
+      }
+      else
+      {
+         DU_LOG("\nERROR  --> SCH: Unable to get any free block for Paging at SFN:%d, SLOT:%d",\
+               pdschTime.sfn, pdschTime.slot);
+         break;
+      }
+      /*Fill PDCCH: PDCCH Cfg is same as SIB1 as Paging will be a broadcast message*/
+      memcpy(&dlPageAlloc.pagePdcchCfg, &cell->cellCfg.sib1SchCfg.sib1PdcchCfg, sizeof(PdcchCfg));
+      dlPageAlloc.pagePdcchCfg.dci.rnti = P_RNTI;
+
+      /*Fill BWP*/
+      memcpy(&dlPageAlloc.bwp, &cell->cellCfg.sib1SchCfg.bwp, sizeof(BwpCfg)); 
+
+      /*Fill PDSCH*/
+      if(schFillPagePdschCfg(cell, &dlPageAlloc.pagePdschCfg, pdschTime, tbSize, pageInfo->mcs, startPrb) != ROK)
+      {
+         DU_LOG("\nERROR  --> SCH: Issue in PDSCH Allocation for Paging at SFN:%d, SLOT:%d",\
+               pdschTime.sfn, pdschTime.slot);
+         break;
+      }
+      dlPageAlloc.pagePdcchCfg.dci.pdschCfg = &dlPageAlloc.pagePdschCfg;
+
+      /*Fill Page PDU information*/
+      dlPageAlloc.dlPagePduLen = pageInfo->msgLen;
+
+      SCH_ALLOC(dlPageAlloc.dlPagePdu, sizeof(dlPageAlloc.dlPagePduLen));
+
+      if(dlPageAlloc.dlPagePdu == NULLP)
+      {
+         DU_LOG("\nERROR  --> SCH: Memory Allocation Failed during Page Resource allocation");
+         break;
+      }
+      memcpy(dlPageAlloc.dlPagePdu, pageInfo->pagePdu, dlPageAlloc.dlPagePduLen);
+
+      /* Send msg to MAC */
+      if(sendDlPageAllocToMac(&dlPageAlloc, schInst) != ROK)
+      {
+         DU_LOG("\nERROR  -->  SCH : Sending DL Paging allocation from SCH to MAC failed");
+         SCH_FREE(dlPageAlloc.dlPagePdu, sizeof(dlPageAlloc.dlPagePduLen));
+         break;
+      }
+      ret = ROK;
+      break;
+   }
+
+   /*Remove the Page Node*/
+   SCH_FREE(pageInfo->pagePdu, pageInfo->msgLen);
+   schDeleteFromPageInfoList(&(cell->pageCb.pageIndInfoRecord[currTime.sfn]), pageInfoNode);
+
+   return(ret);
+
+}
+
 /*******************************************************************
  *
  * @brief Handles slot indication at SCH 
@@ -653,6 +789,9 @@ uint8_t schProcessSlotInd(SlotTimingInfo *slotInd, Inst schInst)
       }
    }
 
+   /*Process Paging Msg*/
+   schProcDlPageAlloc(cell, *slotInd, schInst);
+
    /* Select first UE in the linked list to be scheduled next */
    pendingUeNode = cell->ueToBeScheduled.first;
    if(pendingUeNode)
diff --git a/src/5gnrsch/sch_utils.c b/src/5gnrsch/sch_utils.c
index 0b65fb454..140efc8b9 100644
--- a/src/5gnrsch/sch_utils.c
+++ b/src/5gnrsch/sch_utils.c
@@ -1539,7 +1539,7 @@ void deleteLcLL(CmLListCp *lcLL)
  *        
  *
  *************************************************************************/
-uint32_t calculateEstimateTBSize(uint32_t reqBO, uint16_t mcsIdx,uint8_t numSymbols,\
+uint32_t calculateEstimateTBSize(uint32_t reqBO, uint16_t mcsIdx, uint8_t numSymbols,\
                                    uint16_t maxPRB, uint16_t *estPrb)
 {
    uint32_t tbs = 0, effecBO = 0;
@@ -1564,6 +1564,76 @@ uint32_t calculateEstimateTBSize(uint32_t reqBO, uint16_t mcsIdx,uint8_t numSymb
    effecBO = MIN(tbs,reqBO);
    return (effecBO);
 }
+
+
+/*******************************************************************
+*
+* @brief deleting Page Info node from PageInfo List
+*
+* @details
+*
+*    Function : schDeleteFromPageInfoList
+*
+*    Functionality: deleting page Info node from Page Info List
+*
+* @params[in] CmLListCp *list, CmLList *node 
+*
+* @return void 
+*
+* ****************************************************************/
+void schDeleteFromPageInfoList(CmLListCp *list, CmLList *node)
+{
+   SchPageInfo *pageInfo;
+
+   if(node != NULLP)
+   {
+      pageInfo = (SchPageInfo *)node->node;
+      if(deleteNodeFromLList(list, node) == ROK)
+         SCH_FREE(pageInfo, sizeof(SchPageInfo));
+   }
+}
+
+/*******************************************************************
+*
+* @brief searching for Page at a particular SFN 
+*
+* @details
+*
+*    Function : schPageInfoSearchFromPageList
+*
+*    Functionality: searching for Page at a particular SFN 
+*
+* @params[in] SlotTimingInfo slotInfo, CmLListCp *storedPageList
+*
+* @return pointer to SchPageInfo
+*
+* ****************************************************************/
+CmLList *schPageInfoSearchFromPageList(SlotTimingInfo slotInfo, CmLListCp *storedPageList)
+{
+   CmLList         *node = NULLP;
+   SchPageInfo     *pageInfo = NULLP;
+
+   if(storedPageList->count)
+   {
+      CM_LLIST_FIRST_NODE(storedPageList, node);
+      while(node)
+      {
+         pageInfo = (SchPageInfo*)node->node;
+         if(pageInfo == NULLP)
+         {
+            DU_LOG("\nERROR  --> SCH: PageInfo empty");
+         }
+         else if(pageInfo->pageTxTime.sfn == slotInfo.sfn && 
+               (pageInfo->pageTxTime.slot == slotInfo.slot))
+         {
+            return node;
+         }
+         node = node->next;
+      }
+   }
+   return NULLP;
+}
+
 /*Below function for printing will be used in future so disabling it for now*/
 #if 0
 /****************************************************************************
diff --git a/src/5gnrsch/sch_utils.h b/src/5gnrsch/sch_utils.h
index 44a14727b..273164263 100644
--- a/src/5gnrsch/sch_utils.h
+++ b/src/5gnrsch/sch_utils.h
@@ -133,6 +133,10 @@ uint8_t updateLcListReqPRB(CmLListCp *lcLL, uint8_t lcId, uint32_t payloadSize);
 uint32_t calculateEstimateTBSize(uint32_t reqBO, uint16_t mcsIdx,uint8_t numSymbols,\
                                    uint16_t maxPRB, uint16_t *estPrb);
 void deleteLcLL(CmLListCp *lcLL);
+
+CmLList *schPageInfoSearchFromPageList(SlotTimingInfo slotInfo, CmLListCp *storedPageList);
+void schDeleteFromPageInfoList(CmLListCp *list, CmLList *node);
+
 #if 0
 /*Will be enabled for debugging*/
 void printLcLL(CmLListCp *lcLL);
diff --git a/src/cm/mac_sch_interface.c b/src/cm/mac_sch_interface.c
index b6dc192df..249a8e6ed 100644
--- a/src/cm/mac_sch_interface.c
+++ b/src/cm/mac_sch_interface.c
@@ -637,6 +637,24 @@ uint8_t packMacSchPagingInd(Pst *pst,  SchPageInd *pageInd)
    return ROK;
 }
 
+/**
+ * @brief function to pack DL Paging allocation message 
+ *        from MAC to SCH
+ *
+ * @details
+ *
+ *     Function : packSchMacDlPageAlloc 
+ *     
+ *     
+ *  @param[in]  Pst *pst, the post structure     
+ *  @param[in]  DlPageAlloc *dlPageAlloc
+ *  @return  S16
+ *      -# ROK
+ **/
+uint8_t packSchMacDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc)
+{
+   return ROK;
+}
 /**********************************************************************
   End of file
  **********************************************************************/
diff --git a/src/cm/mac_sch_interface.h b/src/cm/mac_sch_interface.h
index 51fece286..c588951c4 100644
--- a/src/cm/mac_sch_interface.h
+++ b/src/cm/mac_sch_interface.h
@@ -43,7 +43,8 @@
 #define EVENT_SLICE_RECFG_RSP_TO_MAC 24
 #define EVENT_RACH_RESOURCE_REQUEST_TO_SCH 25
 #define EVENT_RACH_RESOURCE_RESPONSE_TO_MAC 26
-#define EVENT_PAGING_IND_TO_SCH 27
+#define EVENT_PAGING_IND_TO_SCH      27
+#define EVENT_DL_PAGING_ALLOC        28
 
 /*macros*/
 #define MAX_SSB_IDX 1 /* forcing it as 1 for now. Right value is 64 */
@@ -981,6 +982,20 @@ typedef struct dlSchedInfo
 
 }DlSchedInfo;
 
+typedef struct dlPageAlloc
+{
+   uint16_t       cellId;
+   SlotTimingInfo dlPageTime;
+   uint8_t        ssbIdx;
+   bool           shortMsgInd;
+   uint8_t        shortMsg;
+   BwpCfg         bwp;
+   PdcchCfg       pagePdcchCfg;
+   PdschCfg       pagePdschCfg;
+   uint16_t       dlPagePduLen;
+   uint8_t        *dlPagePdu;
+}DlPageAlloc;
+
 typedef struct tbInfo
 {
    uint8_t  qamOrder;  /* Modulation Order */
@@ -1730,6 +1745,11 @@ typedef uint8_t (*SchMacDlAllocFunc)     ARGS((
 	 DlSchedInfo    *dlSchedInfo   /* dl allocation Info */                      
 	 ));
 
+typedef uint8_t (*SchMacDlPageAllocFunc)     ARGS(( 
+         Pst            *pst,          /* Post Structure */
+         DlPageAlloc *dlPageAlloc      /* dl Page allocation Info */
+         ));
+
 typedef uint8_t (*SchMacUlSchInfoFunc)     ARGS((                     
 	 Pst         *pst,           /* Post Structure */                         
 	 UlSchedInfo *ulSchedInfo    /* UL Alloc Sch  Info */                      
@@ -1877,6 +1897,8 @@ uint8_t packSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *cfgRsp);
 uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *sliceReCfgrsp);
 uint8_t packMacSchPagingInd(Pst *pst,  SchPageInd *pageInd);
 uint8_t MacSchPagingInd(Pst *pst,  SchPageInd *pageInd);
+uint8_t packSchMacDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc);
+uint8_t MacProcDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc);
 /**********************************************************************
   End of file
  **********************************************************************/
diff --git a/src/cu_stub/cu_f1ap_msg_hdl.c b/src/cu_stub/cu_f1ap_msg_hdl.c
index 11607bf05..63a19333c 100644
--- a/src/cu_stub/cu_f1ap_msg_hdl.c
+++ b/src/cu_stub/cu_f1ap_msg_hdl.c
@@ -11460,7 +11460,8 @@ uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
 void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
 {
    uint8_t ieIdx = 0, plmnidx=0, duIdx = 0, ret=ROK, cellIdx = 0;
-   uint32_t duId = 0, nrCellId = 0;
+   uint32_t duId = 0;
+   uint64_t nrCellId = 0;
    DuDb     *duDb = NULLP;
    CuCellCb *cellCb = NULLP;
    BIT_STRING_t nrcellIdentity;
@@ -11511,8 +11512,7 @@ void procF1SetupReq(uint32_t *destDuId, F1AP_PDU_t *f1apMsg)
                               ret = procServedCellPlmnList(&srvCellItem->served_Cell_Information.servedPLMNs);
                               memcpy(&nrcellIdentity, &srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity, sizeof(BIT_STRING_t));
                               
-                              /* TODO : Use bitStringToInt */
-                              nrCellId = nrcellIdentity.buf[4] >> nrcellIdentity.bits_unused;
+                              bitStringToInt(&nrcellIdentity, &nrCellId);
                               SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
                               if(cellCb == NULLP)
                               {
diff --git a/src/du_app/du_cell_mgr.c b/src/du_app/du_cell_mgr.c
index 4762d6545..bb1c8ea82 100644
--- a/src/du_app/du_cell_mgr.c
+++ b/src/du_app/du_cell_mgr.c
@@ -192,7 +192,7 @@ uint8_t duGetCellCb(uint16_t cellId, DuCellCb **cellCb)
 * 
 *  @params[in] DuCellCb *cellCb
 *
-*  @return void 
+*  @return ROK/RFAILURE (uint8_t return)
 * 
 * 
 ******************************************************************************/
@@ -225,6 +225,10 @@ uint8_t checkPagingRecord(DuCellCb *cellCb)
          }
          handlePageInfoLL(pf, pagInfo->i_s, &(pagInfoLLFromPF->pagInfoList), DELETE);
       }
+      if(pagInfoLLFromPF->pagInfoList.first == NULLP)
+      {
+         break;
+      }
    }while(pagInfo != NULLP);
    
    cmHashListDelete(&(cellCb->pagingInfoMap), (PTR)pagInfoLLFromPF);
@@ -258,7 +262,8 @@ uint8_t sendDlPcchIndToMac(MacPcchInd *pcchInd)
       /* Fill Pst */
       FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_DL_PCCH_IND);
       
-      DU_LOG("\nDEBUG   -->  DU_APP: Sending DL PCCH indication to MAC for cellId[%d]", pcchInd->cellId);
+      DU_LOG("\nDEBUG   -->  DU_APP: Sending DL PCCH indication to MAC for cellId[%d] at PF[%d]",\
+                         pcchInd->cellId, pcchInd->pf);
       ret = (*packMacDlPcchIndOpts[pst.selector])(&pst, pcchInd);
       if(ret == RFAILED)
       {
@@ -866,7 +871,7 @@ uint8_t insertPagingRecord(DuCellCb* cellCb, DuPagingMsg *rcvdF1apPagingParam, u
 #if 0
    printPageList(&(cellCb->pagingInfoMap));
 #endif
-   
+
    return ROK;
 
 
diff --git a/src/du_app/du_utils.c b/src/du_app/du_utils.c
index 608efb79a..a1804e000 100644
--- a/src/du_app/du_utils.c
+++ b/src/du_app/du_utils.c
@@ -511,7 +511,7 @@ DuPagInfoList* findPagingInfoFromMap(uint16_t pf, CmHashListCp *pagingInfoMap)
 }
 
 /*Below function for printing will be used in future so disabling it for now*/
-#if 0
+#if 0 
 /*******************************************************************
  * @brief Print the Page Info List and UE Records
  *