[Issue-ID: ODUHIGH-388] PUSCH scheduling using K2
[o-du/l2.git] / src / 5gnrsch / sch_common.c
index dbf5940..fa396ef 100644 (file)
@@ -511,7 +511,8 @@ uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst)
  *         RFAILED - failure
  *
  * ****************************************************************/
-uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueIdx, DlMsgAlloc *msg4Alloc, uint8_t k0Idx)
+uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueId, DlMsgAlloc *dlMsgAlloc,\
+uint8_t pdschStartSymbol, uint8_t pdschNumSymbols)
 {
    uint8_t coreset0Idx = 0;
    uint8_t firstSymbol = 0;
@@ -524,6 +525,7 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
    PdcchCfg *pdcch = NULLP;
    PdschCfg *pdsch = NULLP;
    BwpCfg *bwp = NULLP;
+   DlMsgSchInfo *msg4Alloc = NULLP;
 
    if(cell == NULL)
    {
@@ -531,20 +533,22 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
       return RFAILED;
    }
 
-   if(msg4Alloc == NULL)
+   if(dlMsgAlloc == NULL)
    {
-      DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() :  msg4Alloc is NULL");
+      DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() :  dlMsgAlloc is NULL");
       return RFAILED;
    }
 
+   msg4Alloc = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo];
    initialBwp   = &cell->cellCfg.schInitialDlBwp;
    pdcch = &msg4Alloc->dlMsgPdcchCfg;
    pdsch = &msg4Alloc->dlMsgPdschCfg;
    bwp = &msg4Alloc->bwp;
    coreset0Idx  = initialBwp->pdcchCommon.commonSearchSpace.coresetId;
 
-   msg4Alloc->dlMsgInfo = cell->raCb[ueIdx].dlMsgInfo;
-   msg4Alloc->dlMsgInfo.isMsg4Pdu = true;
+   fillDlMsgInfo(&msg4Alloc->dlMsgInfo, cell->raCb[ueId-1].tcrnti);
+   msg4Alloc->dlMsgInfo.dlMsgPduLen = cell->raCb[ueId-1].dlMsgPduLen;
+
    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
    numRbs     = coresetIdxTable[coreset0Idx][1];
    numSymbols = coresetIdxTable[coreset0Idx][2];
@@ -579,7 +583,7 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
    pdcch->numDlDci = 1;
-   pdcch->dci.rnti = cell->raCb[ueIdx].tcrnti;
+   pdcch->dci.rnti = cell->raCb[ueId-1].tcrnti;
    pdcch->dci.scramblingId = cell->cellCfg.phyCellId;
    pdcch->dci.scramblingRnti = 0;
    pdcch->dci.cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */
@@ -596,7 +600,7 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
    /* fill the PDSCH PDU */
    uint8_t cwCount = 0;
    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
-   pdsch->rnti = cell->raCb[ueIdx].tcrnti;
+   pdsch->rnti = cell->raCb[ueId-1].tcrnti;
    pdsch->pduIndex = 0;
    pdsch->numCodewords = 1;
    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
@@ -623,13 +627,12 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
    pdsch->dmrs.dmrsAddPos       = DMRS_ADDITIONAL_POS;
 
-   pdsch->pdschTimeAlloc.timeAlloc.startSymb =initialBwp->pdschCommon.timeDomRsrcAllocList[k0Idx].startSymbol; 
-   pdsch->pdschTimeAlloc.timeAlloc.numSymb = initialBwp->pdschCommon.timeDomRsrcAllocList[k0Idx].lengthSymbol;
+   pdsch->pdschTimeAlloc.timeAlloc.startSymb = pdschStartSymbol; 
+   pdsch->pdschTimeAlloc.timeAlloc.numSymb = pdschNumSymbols;
 
    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
    pdsch->pdschFreqAlloc.freqAlloc.startPrb = MAX_NUM_RB;
-   pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, \
-   initialBwp->pdschCommon.timeDomRsrcAllocList[k0Idx].lengthSymbol);
+   pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, mcs, pdschNumSymbols);
    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
 
    /* Find total symbols occupied including DMRS */
@@ -664,6 +667,7 @@ uint8_t schDlRsrcAllocMsg4(SchCellCb *cell, SlotTimingInfo msg4Time, uint8_t ueI
    pdsch->txPdschPower.powerControlOffset = 0;
    pdsch->txPdschPower.powerControlOffsetSS = 0;
 
+   msg4Alloc->dlMsgInfo.isMsg4Pdu = true;
    return ROK;
 }
  
@@ -716,7 +720,7 @@ uint16_t schAllocPucchResource(SchCellCb *cell, SlotTimingInfo pucchTime, uint16
  *
  * ****************************************************************/
 uint8_t schDlRsrcAllocDlMsg(SchCellCb *cell, SlotTimingInfo slotTime, uint16_t crnti,
-                uint32_t tbSize, DlMsgAlloc *dlMsgAlloc, uint16_t startPRB)
+                uint32_t tbSize, DlMsgAlloc *dlMsgAlloc, uint16_t startPRB, uint8_t pdschStartSymbol, uint8_t pdschNumSymbols)
 {
    uint8_t ueIdx;
    PdcchCfg *pdcch = NULLP;
@@ -727,9 +731,9 @@ uint8_t schDlRsrcAllocDlMsg(SchCellCb *cell, SlotTimingInfo slotTime, uint16_t c
    SchPdschConfig pdschCfg;
    uint8_t dmrsStartSymbol, startSymbol, numSymbol;
 
-   pdcch = &dlMsgAlloc->dlMsgPdcchCfg;
-   pdsch = &dlMsgAlloc->dlMsgPdschCfg;
-   bwp = &dlMsgAlloc->bwp;
+   pdcch = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo].dlMsgPdcchCfg;
+   pdsch = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo].dlMsgPdschCfg;
+   bwp = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo].bwp;
 
    GET_UE_IDX(crnti, ueIdx);
    ueCb  = cell->ueCb[ueIdx-1];
@@ -800,14 +804,13 @@ uint8_t schDlRsrcAllocDlMsg(SchCellCb *cell, SlotTimingInfo slotTime, uint16_t c
    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
    pdsch->dmrs.dmrsAddPos       = pdschCfg.dmrsDlCfgForPdschMapTypeA.addPos;
 
-   pdsch->pdschTimeAlloc.timeAlloc.startSymb = pdschCfg.timeDomRsrcAllociList[0].startSymbol;
-   pdsch->pdschTimeAlloc.timeAlloc.numSymb = pdschCfg.timeDomRsrcAllociList[0].symbolLength;
+   pdsch->pdschTimeAlloc.timeAlloc.startSymb = pdschStartSymbol; 
+   pdsch->pdschTimeAlloc.timeAlloc.numSymb = pdschNumSymbols;
 
    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
    pdsch->pdschFreqAlloc.freqAlloc.startPrb = startPRB; /*Start PRB will be already known*/
-   pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, ueCb.ueCfg.dlModInfo.mcsIndex, \
-                  pdschCfg.timeDomRsrcAllociList[0].symbolLength);
+   pdsch->pdschFreqAlloc.freqAlloc.numPrb = schCalcNumPrb(tbSize, ueCb.ueCfg.dlModInfo.mcsIndex, pdschNumSymbols);
 
    /* Find total symbols occupied including DMRS */
    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
@@ -1512,6 +1515,7 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *
 {
    CmLList *node = NULLP, *next = NULLP;
    LcInfo *lcNode = NULLP;
+   DlMsgSchInfo *dlMsgSchInfo = NULLP;
 
    if(lcLL == NULLP)
    {
@@ -1529,6 +1533,8 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *
       return;
    }
 
+   dlMsgSchInfo = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo];
+
    /*Traverse List*/
    while(node)
    {
@@ -1541,16 +1547,16 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *
 
          /*Add this LC to dlMsgAlloc so that if this LC gets allocated, BO
           * report for allocation can be sent to MAC*/
-         dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].lcId = lcNode->lcId;
-         dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].schBytes = lcNode->allocBO;
+         dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].lcId = lcNode->lcId;
+         dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes = lcNode->allocBO;
 
          /*Calculate the Total Payload/BO size allocated*/
-         *accumalatedBOSize += dlMsgAlloc->lcSchInfo[dlMsgAlloc->numLc].schBytes; 
+         *accumalatedBOSize += dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes; 
 
          DU_LOG("\nINFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\
-               lcNode->lcId,lcNode->reqBO, dlMsgAlloc->numLc, *accumalatedBOSize);
+               lcNode->lcId,lcNode->reqBO, dlMsgSchInfo->numLc, *accumalatedBOSize);
 
-         dlMsgAlloc->numLc++;
+         dlMsgSchInfo->numLc++;
          /*The LC has been fully allocated, clean it*/
          if(lcNode->reqBO == 0)
          {
@@ -1562,6 +1568,33 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *
    return;
 }
 
+/*******************************************************************
+*
+* @brief fill DL message information for MSG4 and Dedicated DL Msg
+*
+* @details
+*
+*    Function : fillDlMsgInfo
+*
+*    Functionality:
+*       fill DL message information for MSG4 and Dedicated DL Msg
+*
+* @params[in] DlMsgInfo *dlMsgInfo,  uint8_t crnti
+* @return void
+*
+*******************************************************************/
+void fillDlMsgInfo(DlMsgInfo *dlMsgInfo, uint8_t crnti)
+{
+   dlMsgInfo->crnti = crnti;
+   dlMsgInfo->ndi = 1;
+   dlMsgInfo->harqProcNum = 0;
+   dlMsgInfo->dlAssignIdx = 0;
+   dlMsgInfo->pucchTpc = 0;
+   dlMsgInfo->pucchResInd = 0;
+   dlMsgInfo->harqFeedbackInd = 0;
+   dlMsgInfo->dciFormatId = 1;
+}
+
 /*******************************************************************
  *
  * @brief sch Process pending Msg4 Req
@@ -1579,13 +1612,9 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *
  *
  *******************************************************************/
 
-uint8_t schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime)
+bool schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId)
 {
-   bool k1Found = FALSE;  
-   uint16_t pdcchSlot = 0, pdschSlot = 0;
-   uint8_t ueIdx = 0, numK0 = 0, k0TblIdx = 0, k0Index = 0, k0Val = 0;
-   uint8_t k1TblIdx = 0, k1Index = 0, k1Val = 0, numK1 = 0;
-   SchK0K1TimingInfoTbl *k0K1InfoTbl;
+   uint8_t pdschStartSymbol = 0, pdschNumSymbols = 0;
    SlotTimingInfo pdcchTime, pdschTime, pucchTime;
    DlMsgAlloc *dciSlotAlloc = NULLP;    /* Stores info for transmission of PDCCH for Msg4 */
    DlMsgAlloc  *msg4SlotAlloc = NULLP;   /* Stores info for transmission of PDSCH for Msg4 */
@@ -1593,117 +1622,235 @@ uint8_t schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime)
    if(cell == NULL)
    {
       DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() : Cell is NULL");
-      return RFAILED;
+      return false;
+   }
+   
+   if(findValidK0K1Value(cell, currTime, ueId, false, &pdschStartSymbol, &pdschNumSymbols, &pdcchTime, &pdschTime,\
+            &pucchTime) != true )
+   {
+      return false;
    }
 
-   while(ueIdx < MAX_NUM_UE)
+   if(cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] == NULL)
    {
-      if(cell->raCb[ueIdx].msg4recvd == FALSE)
+      SCH_ALLOC(dciSlotAlloc, sizeof(DlMsgAlloc));
+      if(dciSlotAlloc == NULLP)
       {
-         ueIdx++;
-         continue;
+         DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciSlotAlloc");
+         return false;
       }
+      cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = dciSlotAlloc;
+      memset(dciSlotAlloc, 0, sizeof(DlMsgAlloc));
+      GET_CRNTI(dciSlotAlloc->crnti, ueId);
+   }
+   else
+      dciSlotAlloc = cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1];
 
-      ADD_DELTA_TO_TIME(currTime, pdcchTime, PHY_DELTA_DL + SCHED_DELTA);
-      pdcchSlot = pdcchTime.slot;
-#ifdef NR_TDD
-      if(schGetSlotSymbFrmt(pdcchSlot, cell->slotFrmtBitMap) != DL_SLOT)
+   /* Fill PDCCH and PDSCH scheduling information for Msg4 */
+   if((schDlRsrcAllocMsg4(cell, pdschTime, ueId, dciSlotAlloc, pdschStartSymbol, pdschNumSymbols)) != ROK)
+   {
+      DU_LOG("\nERROR  -->  SCH: Scheduling of Msg4 failed in slot [%d]", pdschTime.slot);
+      if(dciSlotAlloc->numSchedInfo == 0)
       {
-         continue;
+         SCH_FREE(dciSlotAlloc, sizeof(DlMsgAlloc));
+         cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
       }
-#endif
-      k0K1InfoTbl = &cell->cellCfg.schInitialDlBwp.k0K1InfoTbl;
-      numK0 = k0K1InfoTbl->k0k1TimingInfo[pdcchSlot].numK0;
-      for(k0TblIdx = 0; k0TblIdx < numK0; k0TblIdx++)
-      {
-         k0Index = k0K1InfoTbl->k0k1TimingInfo[pdcchSlot].k0Indexes[k0TblIdx].k0Index;
-         k0Val = cell->cellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[k0Index].k0;
+      else
+         memset(&dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo], 0, sizeof(DlMsgSchInfo));
+      return false;
+   }
 
-         ADD_DELTA_TO_TIME(pdcchTime, pdschTime, k0Val);
-         pdschSlot = pdschTime.slot;
-#ifdef NR_TDD
-         if(schGetSlotSymbFrmt(pdschSlot, cell->slotFrmtBitMap) != DL_SLOT)
+   /* Check if both DCI and RAR are sent in the same slot.
+    * If not, allocate memory RAR PDSCH slot to store RAR info
+    */
+   if(pdcchTime.slot == pdschTime.slot)
+   {
+      dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo].pduPres = BOTH;
+      dciSlotAlloc->numSchedInfo++;
+   }
+   else
+   {
+      /* Allocate memory to schedule rarSlot to send RAR, pointer will be checked at schProcessSlotInd() */
+      if(cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] == NULL)
+      {
+         SCH_ALLOC(msg4SlotAlloc, sizeof(DlMsgAlloc));
+         if(msg4SlotAlloc == NULLP)
          {
-            continue;
+            DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for msg4SlotAlloc");
+            if(dciSlotAlloc->numSchedInfo == 0)
+            {
+               SCH_FREE(dciSlotAlloc, sizeof(DlMsgAlloc));
+               cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueId-1] = NULLP;
+            }
+            else
+               memset(&dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo], 0, sizeof(DlMsgSchInfo));
+            return false;
          }
+         cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1] = msg4SlotAlloc;
+         memset(msg4SlotAlloc, 0, sizeof(DlMsgAlloc));
+         msg4SlotAlloc->crnti = dciSlotAlloc->crnti;
+      }
+      else
+         msg4SlotAlloc = cell->schDlSlotInfo[pdschTime.slot]->dlMsgAlloc[ueId-1];
+
+      /* Copy all RAR info */
+      memcpy(&msg4SlotAlloc->dlMsgSchedInfo[msg4SlotAlloc->numSchedInfo], \
+         &dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo], sizeof(DlMsgSchInfo));
+      msg4SlotAlloc->dlMsgSchedInfo[msg4SlotAlloc->numSchedInfo].dlMsgPdcchCfg.dci.pdschCfg = \
+         &msg4SlotAlloc->dlMsgSchedInfo[msg4SlotAlloc->numSchedInfo].dlMsgPdschCfg;
+
+      /* Assign correct PDU types in corresponding slots */
+      msg4SlotAlloc->dlMsgSchedInfo[msg4SlotAlloc->numSchedInfo].pduPres = PDSCH_PDU;
+      dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo].pduPres = PDCCH_PDU;
+      dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo].pdschSlot = pdschTime.slot;
+
+      dciSlotAlloc->numSchedInfo++;
+      msg4SlotAlloc->numSchedInfo++;
+   }
+
+   /* PUCCH resource */
+   schAllocPucchResource(cell, pucchTime, cell->raCb[ueId-1].tcrnti);
+
+   cell->schDlSlotInfo[pdcchTime.slot]->pdcchUe = ueId;
+   cell->schDlSlotInfo[pdschTime.slot]->pdschUe = ueId;
+   cell->schUlSlotInfo[pucchTime.slot]->pucchUe = ueId;
+   cell->raCb[ueId-1].msg4recvd = FALSE;
+   return true;
+}
+
+/*******************************************************************
+ *
+ * @brief sch Process pending Sr or Bsr Req
+ *
+ * @details
+ *
+ *    Function : schProcessSrOrBsrReq
+ *
+ *    Functionality:
+ *       sch Process pending Sr or Bsr Req
+ *
+ * @params[in] SchCellCb *cell,  SlotTimingInfo currTime 
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ *******************************************************************/
+bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId)
+{
+   bool k2Found = FALSE;
+   uint8_t lcgIdx = 0;
+   uint8_t startSymb = 0, symbLen = 0;
+   uint8_t k2TblIdx = 0, k2Index = 0, k2Val = 0;
+   uint32_t totDataReq = 0; /* in bytes */
+   SchUeCb *ueCb;
+   SchPuschInfo *puschInfo;
+   DciInfo  *dciInfo = NULLP;
+   SchK2TimingInfoTbl *k2InfoTbl=NULLP;
+   SlotTimingInfo dciTime, puschTime;
+
+   if(cell == NULL)
+   {
+      DU_LOG("\nERROR  -->  SCH: schDlRsrcAllocMsg4() : Cell is NULL");
+      return false;
+   }
+   
+   ueCb = &cell->ueCb[ueId-1];
+
+   /* check for SR */
+   if(ueCb->srRcvd)
+   {
+      totDataReq = UL_GRANT_SIZE; /*fixing so that all control msgs can be handled in SR */
+   }
+   /* check for BSR */
+   if(ueCb->bsrRcvd == true)
+   {
+      for(lcgIdx=0; lcgIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++)
+      {
+         totDataReq+= ueCb->bsrInfo[lcgIdx].dataVol;
+      }
+   }
+
+   if(totDataReq > 0)
+   {
+      /* Calculating time frame to send DCI for SR */
+      ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA);
+#ifdef NR_TDD
+      if(schGetSlotSymbFrmt(dciTime.slot, cell->slotFrmtBitMap) == DL_SLOT)
 #endif
-         numK1 = k0K1InfoTbl->k0k1TimingInfo[pdcchSlot].k0Indexes[k0TblIdx].k1TimingInfo.numK1;
-         for(k1TblIdx = 0; k1TblIdx < numK1; k1TblIdx++)
+      {     
+         if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt)
+            k2InfoTbl = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2InfoTbl;
+         else
+            k2InfoTbl =  &cell->cellCfg.schInitialUlBwp.k2InfoTbl;
+
+         for(k2TblIdx = 0; k2TblIdx < k2InfoTbl->k2TimingInfo[dciTime.slot].numK2; k2TblIdx++)
          {
-            k1Index = k0K1InfoTbl->k0k1TimingInfo[pdcchSlot].k0Indexes[k0TblIdx].k1TimingInfo.k1Indexes[k1TblIdx];
-            k1Val = defaultUlAckTbl[k1Index];
+            k2Index = k2InfoTbl->k2TimingInfo[dciTime.slot].k2Indexes[k2TblIdx];
+
+            if(!ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt)
+            {
+               k2Val = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2;
+               startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol;
+               symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength;
+            }
+            else
+            {
+               k2Val = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].k2;
+               startSymb =  ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].startSymbol;
+               symbLen =  ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].symbolLength;
+            }
 
-            ADD_DELTA_TO_TIME(pdschTime, pucchTime, k1Val);
+            /* Calculating time frame to send PUSCH for SR */
+            ADD_DELTA_TO_TIME(dciTime, puschTime, k2Val);
 #ifdef NR_TDD
-            if(schGetSlotSymbFrmt(pucchTime.slot, cell->slotFrmtBitMap) == DL_SLOT)
+            if(schGetSlotSymbFrmt(puschTime.slot, cell->slotFrmtBitMap) == DL_SLOT)
+               continue;
+#endif
+            if(cell->schUlSlotInfo[puschTime.slot]->puschUe != 0)
             {
                continue;
             }
-#endif
-            k1Found = true;
+            k2Found = true;
             break;
          }
-         if(k1Found)
-            break;
-      }
-
-      /* If K0-K1 combination not found, no scheduling happens */
-      if(!k1Found)
-      {
-         ueIdx++;
-         continue;
       }
-      
-      SCH_ALLOC(dciSlotAlloc, sizeof(DlMsgAlloc));
-      if(dciSlotAlloc == NULLP)
-      {
-         DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciSlotAlloc");
-         return RFAILED;
-      }
-      cell->schDlSlotInfo[pdcchSlot]->dlMsgAlloc = dciSlotAlloc;
 
-      /* Fill PDCCH and PDSCH scheduling information for Msg4 */
-      if((schDlRsrcAllocMsg4(cell, pdschTime, ueIdx, dciSlotAlloc, k0Index)) != ROK)
+      if(k2Found == true)
       {
-         DU_LOG("\nERROR  -->  SCH: Scheduling of Msg4 failed in slot [%d]", pdschSlot);
-         SCH_FREE(dciSlotAlloc, sizeof(DlMsgAlloc));
-         cell->schDlSlotInfo[pdcchSlot]->dlMsgAlloc = NULLP;
-         return RFAILED;
-      }
-      /* Check if both DCI and RAR are sent in the same slot.
-      * If not, allocate memory RAR PDSCH slot to store RAR info
-      */
-      if(pdcchSlot == pdschSlot)
-         dciSlotAlloc->pduPres = BOTH;
-      else
-      {
-         /* Allocate memory to schedule rarSlot to send RAR, pointer will be checked at schProcessSlotInd() */
-         SCH_ALLOC(msg4SlotAlloc, sizeof(DlMsgAlloc));
-         if(msg4SlotAlloc == NULLP)
+         SCH_ALLOC(dciInfo, sizeof(DciInfo));
+         if(!dciInfo)
          {
-            DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for msg4SlotAlloc");
-            SCH_FREE(dciSlotAlloc, sizeof(DlMsgAlloc));
-            cell->schDlSlotInfo[pdcchSlot]->rarAlloc = NULLP;
-            return RFAILED;
+            DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciInfo alloc");
+            return false;
          }
-         cell->schDlSlotInfo[pdschSlot]->dlMsgAlloc = msg4SlotAlloc;
+         cell->schDlSlotInfo[dciTime.slot]->ulGrant = dciInfo;
+         memset(dciInfo,0,sizeof(DciInfo));
 
-         /* Copy all RAR info */
-         memcpy(msg4SlotAlloc, dciSlotAlloc, sizeof(DlMsgAlloc));
-         msg4SlotAlloc->dlMsgPdcchCfg.dci.pdschCfg = &msg4SlotAlloc->dlMsgPdschCfg;
+         /* Update PUSCH allocation */
+         if(schFillPuschAlloc(ueCb, puschTime, totDataReq, k2Val, startSymb, symbLen) == ROK)
+         {
+            if(cell->schUlSlotInfo[puschTime.slot]->schPuschInfo)
+            {
+               puschInfo = cell->schUlSlotInfo[puschTime.slot]->schPuschInfo;
+               if(puschInfo != NULLP)
+               {
+                  /* Fill DCI for UL grant */
+                  schFillUlDci(ueCb, puschInfo, dciInfo);
+                  memcpy(&dciInfo->slotIndInfo, &dciTime, sizeof(SlotTimingInfo));
+                  ueCb->srRcvd = false;
+                  ueCb->bsrRcvd = false;
+                  for(lcgIdx=0; lcgIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++)
+                  {
+                     ueCb->bsrInfo[lcgIdx].dataVol = 0;
+                  }
 
-         /* Assign correct PDU types in corresponding slots */
-         msg4SlotAlloc->pduPres = PDSCH_PDU;
-         dciSlotAlloc->pduPres = PDCCH_PDU;
-         dciSlotAlloc->pdschSlot = pdschSlot;
+                  cell->schUlSlotInfo[puschTime.slot]->puschUe = ueId;
+                  return true;
+               }
+            }
+         }
       }
-
-      /* PUCCH resource */
-      schAllocPucchResource(cell, pucchTime, cell->raCb[ueIdx].tcrnti);
-      cell->raCb[ueIdx].msg4recvd = FALSE;
-      ueIdx++;
    }
-   return ROK;
+   return false;
 }
 /**********************************************************************
   End of file