X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Fdu_app%2Fdu_f1ap_msg_hdl.c;h=ca02b47a7463bdd06d9098c4764fe57d1219d2fa;hb=ed6746a6081339633c3baa314251fcc11b98ce10;hp=2d8a8a9cdfdd8b19526fe7a236b41bda1315cee6;hpb=66916eaaf8212d36b38e4dba88bdf159d7637779;p=o-du%2Fl2.git

diff --git a/src/du_app/du_f1ap_msg_hdl.c b/src/du_app/du_f1ap_msg_hdl.c
index 2d8a8a9cd..ca02b47a7 100644
--- a/src/du_app/du_f1ap_msg_hdl.c
+++ b/src/du_app/du_f1ap_msg_hdl.c
@@ -27,6 +27,13 @@
 #include "du_app_rlc_inf.h"
 #include "du_mgr_main.h"
 #include "du_utils.h"
+#include "RAT-Type.h"
+#include "FeatureSetUplinkPerCC.h"
+#include "FeatureSetDownlinkPerCC.h"
+#include "FeatureSets.h"
+#include "UE-NR-Capability.h"
+#include "UE-CapabilityRAT-Container.h"
+#include "UE-CapabilityRAT-ContainerListRRC.h"
 #include "GNB-DU-System-Information.h"
 #include "CellGroupConfigRrc.h"
 #include "MAC-CellGroupConfig.h"
@@ -69,6 +76,19 @@
 #include "DUtoCURRCContainer.h"
 #include "GBR-QoSFlowInformation.h"
 #include "QoSFlowLevelQoSParameters.h"
+#include "PUCCH-Config.h"
+#include "PUCCH-ResourceSet.h"
+#include "PUCCH-Resource.h"
+#include "PUCCH-PowerControl.h"
+#include "P0-PUCCH.h"
+#include "PUCCH-PathlossReferenceRS.h"
+#include "PUCCH-format0.h"
+#include "PUCCH-format1.h"
+#include "PUCCH-format2.h"
+#include "PUCCH-format3.h"
+#include "PUCCH-format4.h"
+#include "PUCCH-FormatConfig.h"
+#include "SchedulingRequestResourceConfig.h"
 #include<ProtocolIE-Field.h>
 #include "ProtocolExtensionField.h"
 #include "F1AP-PDU.h"
@@ -5508,6 +5528,79 @@ void  freeMacLcCfg(LcCfg *lcCfg)
    memset(lcCfg, 0, sizeof(LcCfg));
 }
 
+/*******************************************************************
+ *
+ * @brief Free UE NR Capability received in UE Context setup request
+ *
+ * @details
+ *
+ *    Function : freeUeNrCapability
+ *
+ *    Functionality:  
+ *       Free UE NR Capability received in UE Context setup request
+ *
+ * @params[in] 
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+void freeUeNrCapability(void *ueNrCapability)
+{
+   uint8_t idx;
+   FeatureSets_t *featureSets;
+   UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
+
+   if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
+   {
+      for(idx = 0; idx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; idx++)
+      {
+         if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx])
+            free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[idx]);
+      }
+      free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
+   }
+
+   if(ueNrCap->featureSets)
+   {
+      featureSets = ueNrCap->featureSets;
+      if(featureSets->featureSetsDownlinkPerCC)
+      {
+         if(featureSets->featureSetsDownlinkPerCC->list.array)
+         {
+            for(idx = 0; idx < featureSets->featureSetsDownlinkPerCC->list.count; idx++)
+            {
+               if(featureSets->featureSetsDownlinkPerCC->list.array[idx])
+               {
+                  if(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL)
+                     free(featureSets->featureSetsDownlinkPerCC->list.array[idx]->supportedModulationOrderDL);
+                  free(featureSets->featureSetsDownlinkPerCC->list.array[idx]);
+               }
+            }
+            free(featureSets->featureSetsDownlinkPerCC->list.array);
+         }
+         free(featureSets->featureSetsDownlinkPerCC);
+      }
+      if(featureSets->featureSetsUplinkPerCC)
+      {
+         if(featureSets->featureSetsUplinkPerCC->list.array)
+         {
+            for(idx = 0; idx < featureSets->featureSetsUplinkPerCC->list.count; idx++)
+            {
+               if(featureSets->featureSetsUplinkPerCC->list.array[idx])
+               {
+                  if(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL)
+                     free(featureSets->featureSetsUplinkPerCC->list.array[idx]->supportedModulationOrderUL);
+                  free(featureSets->featureSetsUplinkPerCC->list.array[idx]);
+               }
+            }
+            free(featureSets->featureSetsUplinkPerCC->list.array);
+         }
+         free(featureSets->featureSetsUplinkPerCC);
+      }
+      free(ueNrCap->featureSets);
+   }   
+}
+
 /*******************************************************************
  *
  * @brief Function to free DuUeCfg
@@ -5526,14 +5619,21 @@ void freeDuUeCfg(DuUeCfg *ueCfg)
 {
    uint8_t lcIdx;
 
+   if(ueCfg->ueNrCapability)
+   {
+      freeUeNrCapability(ueCfg->ueNrCapability);
+      DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
+      ueCfg->ueNrCapability = NULLP;
+   }
    if(ueCfg->cellGrpCfg)
    {
       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
       ueCfg->cellGrpCfg = NULLP;
    }
-   if(ueCfg->maxAggrBitRate)
+   if(ueCfg->ambrCfg)
    {
-      DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->maxAggrBitRate, sizeof(MaxAggrBitRate));
+      memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
+      DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
    }
    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
    {
@@ -5574,6 +5674,7 @@ void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
    }
    freeDuUeCfg(&f1UeDb->duUeCfg);
    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
+   DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
 }
 
 /*******************************************************************
@@ -6477,7 +6578,7 @@ void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
 	 }
       }
    }
-   macPdschCfg->rbgSize = cuPdschCfg->rbg_Size; 
+   macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
@@ -6696,13 +6797,595 @@ void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, Pusch
       }
    }
 }
+
+/*******************************************************************
+ *
+ * @brief Function to fill pucch Power Control
+ *
+ * @details
+ *
+ *    Function : extractPucchPowerControl
+ *
+ *    Functionality: Function to fill pucch Power Control
+ *
+ * @params[in] PucchPowerControl *pwrCtrl,
+ *             struct PUCCH_PowerControl *cuPwrCtrlCfg
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
+{
+   uint8_t arrIdx;
+
+   if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
+      pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
+   if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
+      pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
+   if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
+      pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
+   if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
+      pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
+   if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
+      pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
+   if(cuPwrCtrlCfg->p0_Set)
+   {
+      pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
+      for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
+      {
+         pwrCtrl->p0Set[arrIdx].p0PucchId =\
+	    cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
+         pwrCtrl->p0Set[arrIdx].p0PucchVal =\
+	    cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
+      }
+   }
+   if(cuPwrCtrlCfg->pathlossReferenceRSs)
+   {
+      pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
+      for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
+      {
+         pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
+	    cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
+      }
+   }
+}
+ 
+ /*******************************************************************
+ *
+ * @brief Function to extractResrcSetToAddModList sent by CU
+ *
+ * @details
+ *
+ *    Function : extractResrcSetToAddModList
+ *
+ *    Functionality: Fucntion to extractResrcSetToAddModList
+ *
+ * @params[in] PucchResrcSetCfg pointer,
+ *             struct PUCCH_Config__resourceSetToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
+{
+   uint8_t arrIdx, rsrcListIdx;
+
+   macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count; 
+   for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
+   {
+      macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
+         cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
+      macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
+         cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
+      for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
+      {
+         macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
+            *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
+      }
+      macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
+         *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
+   }
+}/* End of extractResrcSetToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills extractResrcToAddModList sent by CU
+ *
+ * @details
+ *
+ *    Function : extractResrcToAddModList
+ *
+ *    Functionality: Fills extractResrcToAddModList
+ *
+ * @params[in] PucchResrcCfg pointer,
+ *             struct PUCCH_Config__resourceToAddModList pointer
+ * @return ROk/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
+{
+   uint8_t arrIdx;
+   
+   macResrcList->resrcToAddModListCount = cuResrcList->list.count;
+   for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
+   {
+      macResrcList->resrcToAddModList[arrIdx].resrcId      =\
+        cuResrcList->list.array[arrIdx]->pucch_ResourceId; 
+      macResrcList->resrcToAddModList[arrIdx].startPrb     =\
+        cuResrcList->list.array[arrIdx]->startingPRB;
+      if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
+      {
+         macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
+           *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
+      }
+      if(cuResrcList->list.array[arrIdx]->secondHopPRB)
+      {
+         macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
+           *cuResrcList->list.array[arrIdx]->secondHopPRB;
+      }
+      /* PUCCH RSRC FORMAT */
+      if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
+      {
+         macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
+         if(cuResrcList->list.array[arrIdx]->format.choice.format0)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
+	    if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
+	    {
+               DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
+	       return RFAILED;
+	    }
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
+               cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
+               cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
+               cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
+	 }
+      }
+      else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
+      {
+         macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
+         if(cuResrcList->list.array[arrIdx]->format.choice.format1)
+	 {
+            DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
+	    if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
+	    {
+               DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
+	       return RFAILED;
+	    }
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
+                cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
+                cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
+                cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
+                cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
+	 }
+      }
+      else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
+      {
+         macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
+         if(cuResrcList->list.array[arrIdx]->format.choice.format2)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
+	    if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
+	    {
+               DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
+	       return RFAILED;
+	    }
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
+                cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
+                cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
+                cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
+         }
+      }
+      else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
+      {
+         macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
+         if(cuResrcList->list.array[arrIdx]->format.choice.format3)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
+	    if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
+	    {
+               DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
+	       return RFAILED;
+	    }
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
+                cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
+                cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
+                cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
+         }
+      }
+      else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
+      {
+         macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
+         if(cuResrcList->list.array[arrIdx]->format.choice.format4)
+         {
+	    DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
+	    if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
+	    {
+               DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
+	       return RFAILED;
+	    }
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
+                cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
+	    macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
+                cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
+                cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
+            macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
+                cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
+	 }
+      }
+   }
+   return ROK;
+
+}/* End of extractResrcToAddModList */
+
+/*******************************************************************
+ *
+ * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
+ *
+ * @details
+ *
+ *    Function : fillPucchSchedReqPeriodAndOffset
+ *
+ *    Functionality: To fillPucchSchedReqPeriodAndOffset
+ *
+ * @params[in] macPeriodicty,
+ *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
+   struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
+{
+   macPeriodicty = cuPeriodicty->present;
+   switch(macPeriodicty)
+   {
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
+	 {
+	    macOffset     = cuPeriodicty->choice.sym2;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
+	 {
+	    macOffset     = cuPeriodicty->choice.sym6or7;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
+	 {
+	    macOffset     = cuPeriodicty->choice.sl1;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
+	 {
+	    macOffset = cuPeriodicty->choice.sl2;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
+	 {
+	    macOffset = cuPeriodicty->choice.sl4;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
+	 {
+	    macOffset = cuPeriodicty->choice.sl5;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
+	 {
+	    macOffset = cuPeriodicty->choice.sl8;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
+	 {
+	    macOffset = cuPeriodicty->choice.sl10;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
+	 {
+	    macOffset = cuPeriodicty->choice.sl16;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
+	 {
+	    macOffset = cuPeriodicty->choice.sl20;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
+	 {
+	    macOffset = cuPeriodicty->choice.sl40;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
+	 {
+	    macOffset = cuPeriodicty->choice.sl80;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
+	 {
+	    macOffset = cuPeriodicty->choice.sl160;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
+	 {
+	    macOffset = cuPeriodicty->choice.sl320;
+	    break;
+	 }
+      case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
+	 {
+	    macOffset = cuPeriodicty->choice.sl640;
+	    break;
+	 }
+      default :
+         DU_LOG("\nERROR  --> F1AP : Invalid periodicity %d", macPeriodicty);
+   }
+}
+
+/*******************************************************************
+ *
+ * @brief Function to extractPucchFormatCfg sent by CU
+ *
+ * @details
+ *
+ *    Function : extractPucchFormatCfg
+ *
+ *    Functionality: Function to extractPucchFormatCfg
+ *
+ * @params[in] PucchFormatCfg pointer,
+ *             PUCCH_FormatConfig_t pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
+ {
+    if(cuFormatCfg->interslotFrequencyHopping)
+       macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
+    if(cuFormatCfg->additionalDMRS)  
+       macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
+    if(cuFormatCfg->maxCodeRate)
+       macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
+    if(cuFormatCfg->nrofSlots)  
+       macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
+    if(cuFormatCfg->pi2BPSK)  
+       macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
+    if(cuFormatCfg->simultaneousHARQ_ACK_CSI)  
+       macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
+ }/* End of extractPucchFormatCfg */
+
+/*******************************************************************
+ *
+ * @brief Function to extractSchedReqCfgToAddMod sent by CU
+ *
+ * @details
+ *
+ *    Function : extractSchedReqCfgToAddMod
+ *
+ *    Functionality: Function to extractSchedReqCfgToAddMod
+ *
+ * @params[in] PucchSchedReqCfg pointer,
+ *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
+ * @return void
+ *
+ * ****************************************************************/
+
+void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
+{
+   uint8_t arrIdx;
+
+   macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
+   for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
+   {
+      macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
+         cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
+      macSchedReqCfg->schedAddModList[arrIdx].requestId =\
+         cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
+      if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
+      {
+         fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
+	    macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
+      }
+      if(cuSchedReqList->list.array[arrIdx]->resource)
+      {
+         macSchedReqCfg->schedAddModList[arrIdx].resrc =\
+    	    *cuSchedReqList->list.array[arrIdx]->resource;
+      }
+   }
+
+}/* End of extractSchedReqCfgToAddMod */
+
+ /*******************************************************************
+ *
+ * @brief Fills PucchCfg received by CU
+ *
+ * @details
+ *
+ *    Function : extractPucchCfg
+ *
+ *    Functionality: Fills PucchCfg received  by CU
+ *
+ * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
+ *             PucchCfg *macPucchCfg
+ * @return ROK/RFAILED
+ *
+ * ****************************************************************/
+
+uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)         
+{
+   uint8_t arrIdx;
+
+   if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
+   {
+      if(cuPucchCfg->choice.setup)
+      {
+         /* Resource Set Cfg */ 
+	 if(cuPucchCfg->choice.setup->resourceSetToAddModList)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
+	    if(macPucchCfg->resrcSet == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
+            extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
+	 }
+         
+	 /* Resource Cfg */ 
+	 if(cuPucchCfg->choice.setup->resourceToAddModList)
+	 {
+            DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
+	    if(macPucchCfg->resrc == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
+            extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
+	 }
+         
+	 /* Format 1 Cfg */ 
+	 if(cuPucchCfg->choice.setup->format1)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
+	    if(macPucchCfg->format1 == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
+            extractPucchFormatCfg(macPucchCfg->format1,\
+	       cuPucchCfg->choice.setup->format1->choice.setup);
+	 }
+         
+	 /* Format 2 Cfg */
+         if(cuPucchCfg->choice.setup->format2)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
+	    if(macPucchCfg->format2 == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
+            extractPucchFormatCfg(macPucchCfg->format2,\
+	       cuPucchCfg->choice.setup->format2->choice.setup);
+	 }
+         
+	 /* Format 3 Cfg */
+         if(cuPucchCfg->choice.setup->format3)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
+	    if(macPucchCfg->format3 == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
+            extractPucchFormatCfg(macPucchCfg->format3,\
+	       cuPucchCfg->choice.setup->format3->choice.setup);
+	 }
+
+         /* Format 4 Cfg */
+         if(cuPucchCfg->choice.setup->format4)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
+	    if(macPucchCfg->format4 == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
+            extractPucchFormatCfg(macPucchCfg->format4,\
+	       cuPucchCfg->choice.setup->format4->choice.setup);
+	 }
+
+         /* Sched Req List */
+         if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
+	    if(macPucchCfg->schedReq == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
+            extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
+	    cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
+	 }
+
+         /*TODO: Add support for  Spatial Info */
+
+	 /* MultiCsiCfg */
+         if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
+	 {
+	    DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
+	    if(macPucchCfg->multiCsiCfg == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
+            macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
+	    for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
+	    {
+	       macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
+	         *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
+	    }
+	 }
+
+         /* Dl_DataToUL_ACK */ 
+	 if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
+	 {
+            DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
+	    if(macPucchCfg->dlDataToUlAck == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
+	       return RFAILED;
+	    }
+	    memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
+            macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
+	    for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
+            {
+               macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
+                  *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
+	    }
+	 }
+
+	 /* Power Control */
+         if(cuPucchCfg->choice.setup->pucch_PowerControl)
+	 {
+            DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
+	    if(macPucchCfg->powerControl == NULLP)
+	    {
+	       DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
+	       return RFAILED;
+	    }
+            extractPucchPowerControl(macPucchCfg->powerControl,\
+	       cuPucchCfg->choice.setup->pucch_PowerControl);
+	 }
+      }
+   }
+   return ROK;
+}
+
 /*******************************************************************
  *
  * @brief Fills ServingCellReconfig received by CU
  *
  * @details
  *
- *    Function : extractServingCellReconfig
+ *    Function : extractSpCellDedicatedCfg
  *
  *    Functionality: Fills ServingCellReconfig received  by CU
  *
@@ -6711,7 +7394,7 @@ void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, Pusch
  * @return ROK/RFAILD
  *
  * ****************************************************************/
-uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
+uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
 {
    uint8_t ret = ROK;
    BWP_DownlinkDedicated_t *dlBwp = NULLP;
@@ -6724,6 +7407,7 @@ uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCf
       {
          if(dlBwp->pdcch_Config->choice.setup)
 	 {
+	    macSrvCellCfg->initDlBwp.pdcchPresent = true;
 	    extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
 	 }
       }
@@ -6731,6 +7415,7 @@ uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCf
       {
          if(dlBwp->pdsch_Config->choice.setup)
 	 {
+	    macSrvCellCfg->initDlBwp.pdschPresent = true;
 	    extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
 	 }
       }
@@ -6755,7 +7440,7 @@ uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCf
 	 }
 	 else
 	 {
-	    DU_LOG("\nMemory Alloc failed for bwpInactivityTmr at extractServingCellReconfig()");
+	    DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
 	    return RFAILED;
 	 }
       }
@@ -6767,7 +7452,7 @@ uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCf
          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
          if(ret == RFAILED)
 	 {
-	    DU_LOG("\nFailed at extractPdschServingCellCfg()");
+	    DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
 	    return RFAILED;
 	 }
       }
@@ -6785,12 +7470,12 @@ uint8_t extractServingCellReconfig(ServingCellConfig_t *cuSrvCellCfg, ServCellCf
 	if(ulBwp->pucch_Config)
 	{
 	   macSrvCellCfg->initUlBwp.pucchPresent = true;
-           //extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg); 
+	   memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
+           extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg); 
 	}
      }
      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
-
    }
    return ret;
 }
@@ -6864,8 +7549,6 @@ uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg
 		   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
 	       }
 	    }
-
-
 	 }
       }
       /* Fill Physical Cell Group Reconfig */
@@ -6891,10 +7574,10 @@ uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg
 	 if(cellGrp->spCellConfig->spCellConfigDedicated)
 	 {
 	    servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
-            ret = extractServingCellReconfig(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
+            ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
 	    if(ret == RFAILED)
 	    {
-	       DU_LOG("\n Failed at extractServingCellReconfig()");
+	       DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
 	    }
 	 }
       }
@@ -6937,6 +7620,115 @@ uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
    return ret;
 }
 
+/*******************************************************************
+ *
+ * @brief Filling modulation info in mac ue cfg
+ *
+ * @details
+ *
+ *    Function : duFillModulationDetails
+ *
+ *    Functionality: Filling modulation info in mac ue cfg
+ *
+ * @params[in] MAC UE Config to be updated
+ *             Current UE configuration
+ *             UE NR capability from CU
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
+{
+   UE_NR_Capability_t *ueNrCap;
+
+   if(ueCap)
+      ueNrCap = (UE_NR_Capability_t *)ueCap;
+
+   /* Filling DL modulation info */
+   if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
+	 ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
+	 ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
+   {
+      switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
+      {
+	 case ModulationOrder_qpsk:
+	    {
+	       ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
+	       break;
+	    }
+	 case ModulationOrder_qam16:
+	    {
+	       ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
+	       break;
+	    }
+	 case ModulationOrder_qam64:
+	    {
+	       ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
+	       ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
+	       ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
+	       break;
+	    }
+	 case ModulationOrder_qam256:
+	    {
+	       ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
+	       break;
+	    }
+	 default:
+	    {
+	       DU_LOG("\nDU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
+	       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+	       break;
+	    }
+      }
+   }
+   else
+   {
+      memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
+   }
+
+   /* Filling UL modulation info */
+   if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
+	 ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
+	 ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
+   {
+      switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
+      {
+	 case ModulationOrder_qpsk:
+	    {
+	       ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
+	       break;
+	    }
+	 case ModulationOrder_qam16:
+	    {
+	       ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
+	       ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
+	       ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
+	       break;
+	    }
+	 case ModulationOrder_qam64:
+	    {
+	       ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
+	       break;
+	    }
+	 case ModulationOrder_qam256:
+	    {
+	       ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
+	       break;
+	    }
+	 default:
+	    {
+	       DU_LOG("\nDU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
+	       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+	       break;
+	    }
+      }
+   }
+   else
+   {
+      memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
+   }
+}
+
 /*******************************************************************
  *
  * @brief Function to extract cellGrp Info present in cutoDu cont
@@ -7231,6 +8023,87 @@ uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
    return ret;
 }
 
+/*******************************************************************
+ *
+ * @brief Extract UE capability info 
+ *
+ * @details
+ *
+ *    Function : extractUeCapability
+ *
+ *    Functionality: Extract UE capability info and stores in ue Cb
+ *
+ * @params[in] Octet string of UE capability RAT container list
+ * @return ROK     - success
+ *         RFAILED - failure
+ *
+ * ****************************************************************/
+UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
+{
+   uint8_t  idx;
+   uint16_t recvBufLen;
+   asn_dec_rval_t rval;
+   UE_NR_Capability_t  *ueNrCap = NULLP;
+   UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
+
+   /* Decoding UE Capability RAT Container List */
+   recvBufLen = ueCapablityListBuf->size;
+   DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+   if(!ueCapRatContList)
+   {
+      DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+      return NULLP;
+   }
+   memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+   memset(&rval, 0, sizeof(asn_dec_rval_t));
+   rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
+          ueCapablityListBuf->buf, recvBufLen, 0, 0);
+   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+   {
+      DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+      return NULLP;
+   }
+   xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
+
+   /* Free encoded buffer after decoding */
+   free(ueCapablityListBuf->buf);
+
+   for(idx = 0; idx < ueCapRatContList->list.count; idx++)
+   {
+      if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
+      {
+         /* Decoding UE NR Capability */
+          recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
+          DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
+          if(!ueNrCap)
+          {
+             DU_LOG("\nF1AP : Memory allocation failed in extractUeCapability");
+             DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+             return NULLP;
+          } 
+          memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
+          memset(&rval, 0, sizeof(asn_dec_rval_t));
+          rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
+                 ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
+          if(rval.code == RC_FAIL || rval.code == RC_WMORE)
+          {
+             DU_LOG("\nF1AP : ASN decode failed at decodeCellGrpCfg()");
+             return NULLP;
+          }
+          xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
+          
+          /* Free encoded buffer after decoding */
+          free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
+      }
+      free(ueCapRatContList->list.array[idx]);
+   }
+
+   /* Free Memory*/
+   free(ueCapRatContList->list.array);
+   DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
+   return ueNrCap;
+}
+
 /*******************************************************************
  *
  * @brief Process UE context setup request from CU
@@ -7250,7 +8123,7 @@ uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
 {
    uint8_t    ret, ieIdx, ueIdx, lcId, cellIdx;
    bool ueCbFound = false;
-   uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
+   uint32_t gnbCuUeF1apId, gnbDuUeF1apId, bitRateSize;
    DuUeCb   *duUeCb = NULLP;
    UEContextSetupRequest_t   *ueSetReq = NULLP;
     
@@ -7311,6 +8184,12 @@ uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
 	    break;
          case ProtocolIE_ID_id_CUtoDURRCInformation:
 	    {
+               if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
+               {
+                  duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
+                     extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
+                        uE_CapabilityRAT_ContainerList, duUeCb);
+               }
 	       if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
 	       {
                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
@@ -7387,32 +8266,30 @@ uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
 	       }
 	       break;
 	    }
-	 //TODO: To handle maxAggrBitRate case,
-	 // Dependency: The protocolIE is not specified in ASN
-#if 0
-	 case ProtocolIE_ID_id_ULPDUSessionAggregateMaximumBitRate:            {
+	 case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
+	     {
                /* MaximumBitRate Uplink */
 	       bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
 	       if(bitRateSize > 0)
 	       {
-                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.maxAggrBitRate, bitRateSize);
-		  if(!duUeCb->f1UeDb->duUeCfg.maxAggrBitRate)
+                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
+		  if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
 		  {
 	             DU_LOG("\nDU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
 	             ret = RFAILED;
 		  }
 		  else
 		  {
-                     duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->ulBits =\
-		     *ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf;
-                     duUeCb->f1UeDb->duUeCfg.maxAggrBitRate->dlBits = 0;
+		     memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg)); 
+                     memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
+		     ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
+                     duUeCb->f1UeDb->duUeCfg.ambrCfg->dlBr = 0;
 		  }
 	       }
 	       else
 	          ret = RFAILED;
 	       break;
 	    }
-#endif
 	 default:
 	    {
 	       break;
@@ -7674,6 +8551,7 @@ uint8_t BuildAndSendUeContextSetupRsp(uint8_t ueIdx, uint8_t cellId)
 	             choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
 	    /* Free UeContext Db created during Ue context Req */
 	    freeF1UeDb(ueCb->f1UeDb);
+	    ueCb->f1UeDb = NULLP;
          }
       }
       else