Fix warning and compile error.

openair2/RRC/NR/rrc_gNB_NGAP.c

@@ -126,6 +126,7 @@ nr_rrc_pdcp_config_security(
 //------------------------------------------------------------------------------
 {
   NR_SRB_ToAddModList_t              *SRB_configList = ue_context_pP->ue_context.SRB_configList;
+  (void)SRB_configList;
   uint8_t                            *kRRCenc = NULL;
   uint8_t                            *kRRCint = NULL;
   uint8_t                            *kUPenc = NULL;

openair2/RRC/NR_UE/rrc_UE.c

@@ -192,6 +192,7 @@ extern rlc_op_status_t nr_rrc_rlc_config_asn1_req (const protocol_ctxt_t   * con
 
 // from LTE-RRC DL-DCCH RRCConnectionReconfiguration nr-secondary-cell-group-config (encoded)
 int8_t nr_rrc_ue_decode_secondary_cellgroup_config(
+    const module_id_t module_id,
     const uint8_t *buffer,
     const uint32_t size ){
     
@@ -215,11 +216,11 @@ int8_t nr_rrc_ue_decode_secondary_cellgroup_config(
             return -1;
     }
 
-    if(NR_UE_rrc_inst->cell_group_config == NULL){
-        NR_UE_rrc_inst->cell_group_config = cell_group_config;
-        nr_rrc_ue_process_scg_config(cell_group_config);
+    if(NR_UE_rrc_inst[module_id].cell_group_config == NULL){
+        NR_UE_rrc_inst[module_id].cell_group_config = cell_group_config;
+        nr_rrc_ue_process_scg_config(module_id,cell_group_config);
     }else{
-        nr_rrc_ue_process_scg_config(cell_group_config);
+        nr_rrc_ue_process_scg_config(module_id,cell_group_config);
         SEQUENCE_free(&asn_DEF_NR_CellGroupConfig, (void *)cell_group_config, 0);
     }
 
@@ -239,67 +240,62 @@ int8_t nr_rrc_ue_process_RadioBearerConfig(NR_RadioBearerConfig_t *RadioBearerCo
 
 // from LTE-RRC DL-DCCH RRCConnectionReconfiguration nr-secondary-cell-group-config (decoded)
 // RRCReconfiguration
-int8_t nr_rrc_ue_process_rrcReconfiguration(NR_RRCReconfiguration_t *rrcReconfiguration){
-
-    switch(rrcReconfiguration->criticalExtensions.present){
-        case NR_RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration:
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig != NULL){
-                if(NR_UE_rrc_inst->radio_bearer_config == NULL){
-                    NR_UE_rrc_inst->radio_bearer_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig;                
-                }else{
-                    nr_rrc_ue_process_RadioBearerConfig(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
-                }
-            }
-
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup != NULL){
-                NR_CellGroupConfig_t *cellGroupConfig = NULL;
-                uper_decode(NULL,
-                            &asn_DEF_NR_CellGroupConfig,   //might be added prefix later
-                            (void **)&cellGroupConfig,
-                            (uint8_t *)rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->buf,
-                            rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->size, 0, 0); 
-
-		xer_fprint(stdout, &asn_DEF_NR_CellGroupConfig, (const void*)cellGroupConfig);
-
-                if(NR_UE_rrc_inst->cell_group_config == NULL){
-                    //  first time receive the configuration, just use the memory allocated from uper_decoder. TODO this is not good implementation, need to maintain RRC_INST own structure every time.
-                    NR_UE_rrc_inst->cell_group_config = cellGroupConfig;
-                    nr_rrc_ue_process_scg_config(cellGroupConfig);
-                }else{
-                    //  after first time, update it and free the memory after.
-                    SEQUENCE_free(&asn_DEF_NR_CellGroupConfig, (void *)NR_UE_rrc_inst->cell_group_config, 0);
-                    NR_UE_rrc_inst->cell_group_config = cellGroupConfig;
-                    nr_rrc_ue_process_scg_config(cellGroupConfig);
-                }
-                
-            }
-
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig != NULL){
-                if(NR_UE_rrc_inst->meas_config == NULL){
-                    NR_UE_rrc_inst->meas_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig;
-                }else{
-                    //  if some element need to be updated
-                    nr_rrc_ue_process_meas_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig);
-                }
-               
-            }
-
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->lateNonCriticalExtension != NULL){
-                //  unuse now
-            }
-
-            if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension != NULL){
-                // unuse now
-            }
-            break;
-        case NR_RRCReconfiguration__criticalExtensions_PR_NOTHING:
-        case NR_RRCReconfiguration__criticalExtensions_PR_criticalExtensionsFuture:
-        default:
-            break;
-    }
-    //nr_rrc_mac_config_req_ue(); 
+int8_t nr_rrc_ue_process_rrcReconfiguration(const module_id_t module_id, NR_RRCReconfiguration_t *rrcReconfiguration){
+
+  switch(rrcReconfiguration->criticalExtensions.present){
+    case NR_RRCReconfiguration__criticalExtensions_PR_rrcReconfiguration:
+      if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig != NULL){
+        if(NR_UE_rrc_inst[module_id].radio_bearer_config == NULL){
+          NR_UE_rrc_inst[module_id].radio_bearer_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig;                
+        }else{
+          nr_rrc_ue_process_RadioBearerConfig(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->radioBearerConfig);
+        }
+      }
+      if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup != NULL){
+        NR_CellGroupConfig_t *cellGroupConfig = NULL;
+        uper_decode(NULL,
+                    &asn_DEF_NR_CellGroupConfig,   //might be added prefix later
+                    (void **)&cellGroupConfig,
+                    (uint8_t *)rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->buf,
+                    rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->secondaryCellGroup->size, 0, 0); 
+
+        xer_fprint(stdout, &asn_DEF_NR_CellGroupConfig, (const void*)cellGroupConfig);
+
+        if(NR_UE_rrc_inst[module_id].cell_group_config == NULL){
+          //  first time receive the configuration, just use the memory allocated from uper_decoder. TODO this is not good implementation, need to maintain RRC_INST own structure every time.
+          NR_UE_rrc_inst[module_id].cell_group_config = cellGroupConfig;
+          nr_rrc_ue_process_scg_config(module_id,cellGroupConfig);
+        }else{
+          //  after first time, update it and free the memory after.
+          SEQUENCE_free(&asn_DEF_NR_CellGroupConfig, (void *)NR_UE_rrc_inst[module_id].cell_group_config, 0);
+          NR_UE_rrc_inst[module_id].cell_group_config = cellGroupConfig;
+          nr_rrc_ue_process_scg_config(module_id,cellGroupConfig);
+        }
+      }
+      if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig != NULL){
+        if(NR_UE_rrc_inst[module_id].meas_config == NULL){
+          NR_UE_rrc_inst[module_id].meas_config = rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig;
+        }else{
+          //  if some element need to be updated
+          nr_rrc_ue_process_meas_config(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->measConfig);
+        }
+      }
+      if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->lateNonCriticalExtension != NULL){
+        //  unuse now
+      }
+      if(rrcReconfiguration->criticalExtensions.choice.rrcReconfiguration->nonCriticalExtension != NULL){
+        // unuse now
+      }
+      break;
+    
+    case NR_RRCReconfiguration__criticalExtensions_PR_NOTHING:
+    case NR_RRCReconfiguration__criticalExtensions_PR_criticalExtensionsFuture:
+    default:
+      break;
+  }
+  //nr_rrc_mac_config_req_ue(); 
 
-    return 0;
+  return 0;
 }
 
 
@@ -309,90 +305,89 @@ int8_t nr_rrc_ue_process_meas_config(NR_MeasConfig_t *meas_config){
     return 0;
 }
 
-int8_t nr_rrc_ue_process_scg_config(NR_CellGroupConfig_t *cell_group_config){
-    int i;
-    if(NR_UE_rrc_inst->cell_group_config==NULL){
-      //  initial list
-        if(cell_group_config->spCellConfig != NULL){
-            if(cell_group_config->spCellConfig->spCellConfigDedicated != NULL){
-                if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList != NULL){
-                    for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count; ++i){
-                        RRC_LIST_MOD_ADD(NR_UE_rrc_inst->BWP_Downlink_list, cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[i], bwp_Id);
-                    }
-                }
-            }
-        } 
-    }else{
-        //  maintain list
-        if(cell_group_config->spCellConfig != NULL){
-            if(cell_group_config->spCellConfig->spCellConfigDedicated != NULL){
-                //  process element of list to be add by RRC message
-                if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList != NULL){
-                    for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count; ++i){
-                        RRC_LIST_MOD_ADD(NR_UE_rrc_inst->BWP_Downlink_list, cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[i], bwp_Id);
-                    }
-                }
-                
-
-                //  process element of list to be release by RRC message
-                if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList != NULL){
-                    for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList->list.count; ++i){
-                        NR_BWP_Downlink_t *freeP = NULL;
-                        RRC_LIST_MOD_REL(NR_UE_rrc_inst->BWP_Downlink_list, bwp_Id, *cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList->list.array[i], freeP);
-                        if(freeP != NULL){
-                            SEQUENCE_free(&asn_DEF_NR_BWP_Downlink, (void *)freeP, 0);
-                        }
-                    }
-                }
+int8_t nr_rrc_ue_process_scg_config(const module_id_t module_id, NR_CellGroupConfig_t *cell_group_config){
+  int i;
+  if(NR_UE_rrc_inst[module_id].cell_group_config==NULL){
+    //  initial list
+    if(cell_group_config->spCellConfig != NULL){
+      if(cell_group_config->spCellConfig->spCellConfigDedicated != NULL){
+        if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList != NULL){
+          for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count; ++i){
+            RRC_LIST_MOD_ADD(NR_UE_rrc_inst[module_id].BWP_Downlink_list, cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[i], bwp_Id);
+          }
+        }
+      }
+    }
+  }else{
+    //  maintain list
+    if(cell_group_config->spCellConfig != NULL){
+      if(cell_group_config->spCellConfig->spCellConfigDedicated != NULL){
+        //  process element of list to be add by RRC message
+        if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList != NULL){
+          for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.count; ++i){
+            RRC_LIST_MOD_ADD(NR_UE_rrc_inst[module_id].BWP_Downlink_list, cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToAddModList->list.array[i], bwp_Id);
+          }
+        }
+
+        //  process element of list to be release by RRC message
+        if(cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList != NULL){
+          for(i=0; i<cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList->list.count; ++i){
+            NR_BWP_Downlink_t *freeP = NULL;
+            RRC_LIST_MOD_REL(NR_UE_rrc_inst[module_id].BWP_Downlink_list, bwp_Id, *cell_group_config->spCellConfig->spCellConfigDedicated->downlinkBWP_ToReleaseList->list.array[i], freeP);
+            if(freeP != NULL){
+              SEQUENCE_free(&asn_DEF_NR_BWP_Downlink, (void *)freeP, 0);
             }
+          }
         }
-    } 
+      }
+    }
+  } 
 
-    return 0;
+  return 0;
 }
 
 
-
-
 void process_nsa_message(NR_UE_RRC_INST_t *rrc, nsa_message_t nsa_message_type, void *message,int msg_len) {
-
+  module_id_t module_id=0; // TODO
   switch (nsa_message_type) {
     case nr_SecondaryCellGroupConfig_r15:
       {
-	NR_RRCReconfiguration_t *RRCReconfiguration=NULL;
-	asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
-							&asn_DEF_NR_RRCReconfiguration,
-							(void **)&RRCReconfiguration,
-							(uint8_t *)message,
-							msg_len); 
-	
-	if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
-	  LOG_E(RRC,"NR_RRCReconfiguration decode error\n");
-	  // free the memory
-	  SEQUENCE_free( &asn_DEF_NR_RRCReconfiguration, RRCReconfiguration, 1 );
-	  return;
-	}      
-	nr_rrc_ue_process_rrcReconfiguration(RRCReconfiguration);
-      }
+        NR_RRCReconfiguration_t *RRCReconfiguration=NULL;
+        asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+                                &asn_DEF_NR_RRCReconfiguration,
+                                (void **)&RRCReconfiguration,
+                                (uint8_t *)message,
+                                msg_len); 
+        
+        if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+          LOG_E(RRC,"NR_RRCReconfiguration decode error\n");
+          // free the memory
+          SEQUENCE_free( &asn_DEF_NR_RRCReconfiguration, RRCReconfiguration, 1 );
+          return;
+        }
+        nr_rrc_ue_process_rrcReconfiguration(module_id,RRCReconfiguration);
+        }
       break;
+    
     case nr_RadioBearerConfigX_r15:
       {
-	NR_RadioBearerConfig_t *RadioBearerConfig=NULL;
-	asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
-							&asn_DEF_NR_RadioBearerConfig,
-							(void **)&RadioBearerConfig,
-							(uint8_t *)message,
-							msg_len); 
-	
-	if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
-	  LOG_E(RRC,"NR_RadioBearerConfig decode error\n");
-	  // free the memory
-	  SEQUENCE_free( &asn_DEF_NR_RadioBearerConfig, RadioBearerConfig, 1 );
-	  return;
-	}      
-	nr_rrc_ue_process_RadioBearerConfig(RadioBearerConfig);
+        NR_RadioBearerConfig_t *RadioBearerConfig=NULL;
+        asn_dec_rval_t dec_rval = uper_decode_complete( NULL,
+                                &asn_DEF_NR_RadioBearerConfig,
+                                (void **)&RadioBearerConfig,
+                                (uint8_t *)message,
+                                msg_len); 
+        
+        if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
+          LOG_E(RRC,"NR_RadioBearerConfig decode error\n");
+          // free the memory
+          SEQUENCE_free( &asn_DEF_NR_RadioBearerConfig, RadioBearerConfig, 1 );
+          return;
+        }
+        nr_rrc_ue_process_RadioBearerConfig(RadioBearerConfig);
       }
       break;
+    
     default:
       AssertFatal(1==0,"Unknown message %d\n",nsa_message_type);
       break;
@@ -401,104 +396,105 @@ void process_nsa_message(NR_UE_RRC_INST_t *rrc, nsa_message_t nsa_message_type,
 }
 
 NR_UE_RRC_INST_t* openair_rrc_top_init_ue_nr(char* rrc_config_path){
+  int nr_ue;
+  if(NB_NR_UE_INST > 0){
+    NR_UE_rrc_inst = (NR_UE_RRC_INST_t *)malloc(NB_NR_UE_INST * sizeof(NR_UE_RRC_INST_t));
+    memset(NR_UE_rrc_inst, 0, NB_NR_UE_INST * sizeof(NR_UE_RRC_INST_t));
+    for(nr_ue=0;nr_ue<NB_NR_UE_INST;nr_ue++){
+      // fill UE-NR-Capability @ UE-CapabilityRAT-Container here.
+      NR_UE_rrc_inst[nr_ue].selected_plmn_identity = 1;
+      //  init RRC lists
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RLC_Bearer_Config_list, NR_maxLC_ID);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SchedulingRequest_list, NR_maxNrofSR_ConfigPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TAG_list, NR_maxNrofTAGs);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TDD_UL_DL_SlotConfig_list, NR_maxNrofSlots);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].BWP_Downlink_list, NR_maxNrofBWPs);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ControlResourceSet_list[0], 3);   //  for init-dl-bwp
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ControlResourceSet_list[1], 3);   //  for dl-bwp id=0
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ControlResourceSet_list[2], 3);   //  for dl-bwp id=1
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ControlResourceSet_list[3], 3);   //  for dl-bwp id=2
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ControlResourceSet_list[4], 3);   //  for dl-bwp id=3
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SearchSpace_list[0], 10);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SearchSpace_list[1], 10);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SearchSpace_list[2], 10);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SearchSpace_list[3], 10);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SearchSpace_list[4], 10);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SlotFormatCombinationsPerCell_list[0], NR_maxNrofAggregatedCellsPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SlotFormatCombinationsPerCell_list[1], NR_maxNrofAggregatedCellsPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SlotFormatCombinationsPerCell_list[2], NR_maxNrofAggregatedCellsPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SlotFormatCombinationsPerCell_list[3], NR_maxNrofAggregatedCellsPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SlotFormatCombinationsPerCell_list[4], NR_maxNrofAggregatedCellsPerCellGroup);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TCI_State_list[0], NR_maxNrofTCI_States);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TCI_State_list[1], NR_maxNrofTCI_States);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TCI_State_list[2], NR_maxNrofTCI_States);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TCI_State_list[3], NR_maxNrofTCI_States);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].TCI_State_list[4], NR_maxNrofTCI_States);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RateMatchPattern_list[0], NR_maxNrofRateMatchPatterns);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RateMatchPattern_list[1], NR_maxNrofRateMatchPatterns);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RateMatchPattern_list[2], NR_maxNrofRateMatchPatterns);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RateMatchPattern_list[3], NR_maxNrofRateMatchPatterns);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].RateMatchPattern_list[4], NR_maxNrofRateMatchPatterns);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ZP_CSI_RS_Resource_list[0], NR_maxNrofZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ZP_CSI_RS_Resource_list[1], NR_maxNrofZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ZP_CSI_RS_Resource_list[2], NR_maxNrofZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ZP_CSI_RS_Resource_list[3], NR_maxNrofZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].ZP_CSI_RS_Resource_list[4], NR_maxNrofZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].Aperidic_ZP_CSI_RS_ResourceSet_list[0], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].Aperidic_ZP_CSI_RS_ResourceSet_list[1], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].Aperidic_ZP_CSI_RS_ResourceSet_list[2], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].Aperidic_ZP_CSI_RS_ResourceSet_list[3], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].Aperidic_ZP_CSI_RS_ResourceSet_list[4], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SP_ZP_CSI_RS_ResourceSet_list[0], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SP_ZP_CSI_RS_ResourceSet_list[1], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SP_ZP_CSI_RS_ResourceSet_list[2], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SP_ZP_CSI_RS_ResourceSet_list[3], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].SP_ZP_CSI_RS_ResourceSet_list[4], NR_maxNrofZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].NZP_CSI_RS_Resource_list, NR_maxNrofNZP_CSI_RS_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].NZP_CSI_RS_ResourceSet_list, NR_maxNrofNZP_CSI_RS_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_IM_Resource_list, NR_maxNrofCSI_IM_Resources);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_IM_ResourceSet_list, NR_maxNrofCSI_IM_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_SSB_ResourceSet_list, NR_maxNrofCSI_SSB_ResourceSets);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_ResourceConfig_list, NR_maxNrofCSI_ResourceConfigurations);
+      RRC_LIST_INIT(NR_UE_rrc_inst[nr_ue].CSI_ReportConfig_list, NR_maxNrofCSI_ReportConfigurations);
+    }
 
-    if(NB_NR_UE_INST > 0){
-        NR_UE_rrc_inst = (NR_UE_RRC_INST_t *)malloc(NB_NR_UE_INST * sizeof(NR_UE_RRC_INST_t));
-        memset(NR_UE_rrc_inst, 0, NB_NR_UE_INST * sizeof(NR_UE_RRC_INST_t));
-
-        // fill UE-NR-Capability @ UE-CapabilityRAT-Container here.
-        NR_UE_rrc_inst[0].selected_plmn_identity = 1;
-        //  init RRC lists
-        RRC_LIST_INIT(NR_UE_rrc_inst->RLC_Bearer_Config_list, NR_maxLC_ID);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SchedulingRequest_list, NR_maxNrofSR_ConfigPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TAG_list, NR_maxNrofTAGs);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TDD_UL_DL_SlotConfig_list, NR_maxNrofSlots);
-        RRC_LIST_INIT(NR_UE_rrc_inst->BWP_Downlink_list, NR_maxNrofBWPs);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ControlResourceSet_list[0], 3);   //  for init-dl-bwp
-        RRC_LIST_INIT(NR_UE_rrc_inst->ControlResourceSet_list[1], 3);   //  for dl-bwp id=0
-        RRC_LIST_INIT(NR_UE_rrc_inst->ControlResourceSet_list[2], 3);   //  for dl-bwp id=1
-        RRC_LIST_INIT(NR_UE_rrc_inst->ControlResourceSet_list[3], 3);   //  for dl-bwp id=2
-        RRC_LIST_INIT(NR_UE_rrc_inst->ControlResourceSet_list[4], 3);   //  for dl-bwp id=3
-        RRC_LIST_INIT(NR_UE_rrc_inst->SearchSpace_list[0], 10);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SearchSpace_list[1], 10);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SearchSpace_list[2], 10);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SearchSpace_list[3], 10);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SearchSpace_list[4], 10);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SlotFormatCombinationsPerCell_list[0], NR_maxNrofAggregatedCellsPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SlotFormatCombinationsPerCell_list[1], NR_maxNrofAggregatedCellsPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SlotFormatCombinationsPerCell_list[2], NR_maxNrofAggregatedCellsPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SlotFormatCombinationsPerCell_list[3], NR_maxNrofAggregatedCellsPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SlotFormatCombinationsPerCell_list[4], NR_maxNrofAggregatedCellsPerCellGroup);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TCI_State_list[0], NR_maxNrofTCI_States);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TCI_State_list[1], NR_maxNrofTCI_States);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TCI_State_list[2], NR_maxNrofTCI_States);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TCI_State_list[3], NR_maxNrofTCI_States);
-        RRC_LIST_INIT(NR_UE_rrc_inst->TCI_State_list[4], NR_maxNrofTCI_States);
-        RRC_LIST_INIT(NR_UE_rrc_inst->RateMatchPattern_list[0], NR_maxNrofRateMatchPatterns);
-        RRC_LIST_INIT(NR_UE_rrc_inst->RateMatchPattern_list[1], NR_maxNrofRateMatchPatterns);
-        RRC_LIST_INIT(NR_UE_rrc_inst->RateMatchPattern_list[2], NR_maxNrofRateMatchPatterns);
-        RRC_LIST_INIT(NR_UE_rrc_inst->RateMatchPattern_list[3], NR_maxNrofRateMatchPatterns);
-        RRC_LIST_INIT(NR_UE_rrc_inst->RateMatchPattern_list[4], NR_maxNrofRateMatchPatterns);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ZP_CSI_RS_Resource_list[0], NR_maxNrofZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ZP_CSI_RS_Resource_list[1], NR_maxNrofZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ZP_CSI_RS_Resource_list[2], NR_maxNrofZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ZP_CSI_RS_Resource_list[3], NR_maxNrofZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->ZP_CSI_RS_Resource_list[4], NR_maxNrofZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->Aperidic_ZP_CSI_RS_ResourceSet_list[0], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->Aperidic_ZP_CSI_RS_ResourceSet_list[1], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->Aperidic_ZP_CSI_RS_ResourceSet_list[2], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->Aperidic_ZP_CSI_RS_ResourceSet_list[3], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->Aperidic_ZP_CSI_RS_ResourceSet_list[4], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SP_ZP_CSI_RS_ResourceSet_list[0], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SP_ZP_CSI_RS_ResourceSet_list[1], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SP_ZP_CSI_RS_ResourceSet_list[2], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SP_ZP_CSI_RS_ResourceSet_list[3], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->SP_ZP_CSI_RS_ResourceSet_list[4], NR_maxNrofZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->NZP_CSI_RS_Resource_list, NR_maxNrofNZP_CSI_RS_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->NZP_CSI_RS_ResourceSet_list, NR_maxNrofNZP_CSI_RS_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->CSI_IM_Resource_list, NR_maxNrofCSI_IM_Resources);
-        RRC_LIST_INIT(NR_UE_rrc_inst->CSI_IM_ResourceSet_list, NR_maxNrofCSI_IM_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->CSI_SSB_ResourceSet_list, NR_maxNrofCSI_SSB_ResourceSets);
-        RRC_LIST_INIT(NR_UE_rrc_inst->CSI_ResourceConfig_list, NR_maxNrofCSI_ResourceConfigurations);
-        RRC_LIST_INIT(NR_UE_rrc_inst->CSI_ReportConfig_list, NR_maxNrofCSI_ReportConfigurations);
-
-	if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra==1) {
-	  // read in files for RRCReconfiguration and RBconfig
-	  FILE *fd;
-	  char filename[1024];
-	  if (rrc_config_path)
-	    sprintf(filename,"%s/reconfig.raw",rrc_config_path);
-	  else
-	    sprintf(filename,"reconfig.raw");
-	  fd = fopen(filename,"r");
+    if (get_softmodem_params()->phy_test==1 || get_softmodem_params()->do_ra==1) {
+      // read in files for RRCReconfiguration and RBconfig
+      FILE *fd;
+      char filename[1024];
+      if (rrc_config_path)
+        sprintf(filename,"%s/reconfig.raw",rrc_config_path);
+      else
+        sprintf(filename,"reconfig.raw");
+      fd = fopen(filename,"r");
           char buffer[1024];
-	  AssertFatal(fd,
-	              "cannot read file %s: errno %d, %s\n",
-	              filename,
-	              errno,
-	              strerror(errno));
-	  int msg_len=fread(buffer,1,1024,fd);
-	  fclose(fd);
-	  process_nsa_message(NR_UE_rrc_inst, nr_SecondaryCellGroupConfig_r15, buffer,msg_len);
-	  if (rrc_config_path)
-	    sprintf(filename,"%s/rbconfig.raw",rrc_config_path);
-	  else
-	    sprintf(filename,"rbconfig.raw");
-	  fd = fopen(filename,"r");
-	  AssertFatal(fd,
-	              "cannot read file %s: errno %d, %s\n",
-	              filename,
-	              errno,
-	              strerror(errno));
-	  msg_len=fread(buffer,1,1024,fd);
-	  fclose(fd);
-	  process_nsa_message(NR_UE_rrc_inst, nr_RadioBearerConfigX_r15, buffer,msg_len); 
-	}
-    }else{
-        NR_UE_rrc_inst = NULL;
+      AssertFatal(fd,
+                  "cannot read file %s: errno %d, %s\n",
+                  filename,
+                  errno,
+                  strerror(errno));
+      int msg_len=fread(buffer,1,1024,fd);
+      fclose(fd);
+      process_nsa_message(NR_UE_rrc_inst, nr_SecondaryCellGroupConfig_r15, buffer,msg_len);
+      if (rrc_config_path)
+        sprintf(filename,"%s/rbconfig.raw",rrc_config_path);
+      else
+        sprintf(filename,"rbconfig.raw");
+      fd = fopen(filename,"r");
+      AssertFatal(fd,
+                  "cannot read file %s: errno %d, %s\n",
+                  filename,
+                  errno,
+                  strerror(errno));
+      msg_len=fread(buffer,1,1024,fd);
+      fclose(fd);
+      process_nsa_message(NR_UE_rrc_inst, nr_RadioBearerConfigX_r15, buffer,msg_len); 
     }
+  }else{
+    NR_UE_rrc_inst = NULL;
+  }
 
-    return NR_UE_rrc_inst;
+  return NR_UE_rrc_inst;
 }
 
 
@@ -535,7 +531,7 @@ int8_t nr_rrc_ue_decode_NR_BCCH_BCH_Message(
     const uint8_t     buffer_len ){
     int i;
     NR_BCCH_BCH_Message_t *bcch_message = NULL;
-    NR_MIB_t *mib = NR_UE_rrc_inst->mib;
+    NR_MIB_t *mib = NR_UE_rrc_inst[module_id].mib;
 
     if(mib != NULL){
         SEQUENCE_free( &asn_DEF_NR_BCCH_BCH_Message, (void *)mib, 1 );
@@ -555,7 +551,7 @@ int8_t nr_rrc_ue_decode_NR_BCCH_BCH_Message(
     if ((dec_rval.code != RC_OK) || (dec_rval.consumed == 0)) {
       printf("NR_BCCH_BCH decode error\n");
       for (i=0; i<buffer_len; i++){
-	printf("%02x ",bufferP[i]);
+    printf("%02x ",bufferP[i]);
       }
       printf("\n");
       // free the memory
@@ -1197,6 +1193,7 @@ int nr_decode_SIB1( const protocol_ctxt_t *const ctxt_pP, const uint8_t gNB_inde
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_UE_DECODE_SIB1, VCD_FUNCTION_OUT );
   return 0;
 }
+
 int nr_decode_BCCH_DLSCH_Message(
   const protocol_ctxt_t *const ctxt_pP,
   const uint8_t                gNB_index,
@@ -1298,275 +1295,270 @@ nr_rrc_ue_process_masterCellGroup(
 )
 //-----------------------------------------------------------------------------
 {
-    NR_CellGroupConfig_t *cellGroupConfig = (NR_CellGroupConfig_t *)masterCellGroup;
-    if( cellGroupConfig->spCellConfig != NULL &&  cellGroupConfig->spCellConfig->reconfigurationWithSync != NULL){
-	    //TODO (perform Reconfiguration with sync according to 5.3.5.5.2)
-	    //TODO (resume all suspended radio bearers and resume SCG transmission for all radio bearers, if suspended)
-    }
-
-    if( cellGroupConfig->rlc_BearerToReleaseList != NULL){
-      //TODO (perform RLC bearer release as specified in 5.3.5.5.3)
-    }
+  NR_CellGroupConfig_t *cellGroupConfig = (NR_CellGroupConfig_t *)masterCellGroup;
+  if( cellGroupConfig->spCellConfig != NULL &&  cellGroupConfig->spCellConfig->reconfigurationWithSync != NULL){
+    //TODO (perform Reconfiguration with sync according to 5.3.5.5.2)
+    //TODO (resume all suspended radio bearers and resume SCG transmission for all radio bearers, if suspended)
+  }
 
-    if( cellGroupConfig->rlc_BearerToAddModList != NULL){
-      //TODO (perform the RLC bearer addition/modification as specified in 5.3.5.5.4)
-    }
+  if( cellGroupConfig->rlc_BearerToReleaseList != NULL){
+    //TODO (perform RLC bearer release as specified in 5.3.5.5.3)
+  }
 
-    if( cellGroupConfig->mac_CellGroupConfig != NULL){
-      //TODO (configure the MAC entity of this cell group as specified in 5.3.5.5.5)
-    }
+  if( cellGroupConfig->rlc_BearerToAddModList != NULL){
+    //TODO (perform the RLC bearer addition/modification as specified in 5.3.5.5.4)
+  }
 
-    if( cellGroupConfig->sCellToReleaseList != NULL){
-      //TODO (perform SCell release as specified in 5.3.5.5.8)
-    }
+  if( cellGroupConfig->mac_CellGroupConfig != NULL){
+    //TODO (configure the MAC entity of this cell group as specified in 5.3.5.5.5)
+  }
 
-    if( cellGroupConfig->spCellConfig != NULL){
-      if (NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig) {
-        memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig,cellGroupConfig->spCellConfig,
-               sizeof(struct NR_SpCellConfig));
-      } else {
-        NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig = cellGroupConfig->spCellConfig;
-      }
-      //TODO (configure the SpCell as specified in 5.3.5.5.7)
-    }
+  if( cellGroupConfig->sCellToReleaseList != NULL){
+    //TODO (perform SCell release as specified in 5.3.5.5.8)
+  }
 
-    if( cellGroupConfig->sCellToAddModList != NULL){
-      //TODO (perform SCell addition/modification as specified in 5.3.5.5.9)
+  if( cellGroupConfig->spCellConfig != NULL){
+    if (NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig) {
+      memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig,cellGroupConfig->spCellConfig,
+             sizeof(struct NR_SpCellConfig));
+    } else {
+      NR_UE_rrc_inst[ctxt_pP->module_id].cell_group_config->spCellConfig = cellGroupConfig->spCellConfig;
     }
+    //TODO (configure the SpCell as specified in 5.3.5.5.7)
+  }
 
-    if( cellGroupConfig->ext2->bh_RLC_ChannelToReleaseList_r16 != NULL){
-      //TODO (perform the BH RLC channel addition/modification as specified in 5.3.5.5.11)
-    }
+  if( cellGroupConfig->sCellToAddModList != NULL){
+    //TODO (perform SCell addition/modification as specified in 5.3.5.5.9)
+  }
 
-    if( cellGroupConfig->ext2->bh_RLC_ChannelToAddModList_r16 != NULL){
-      //TODO (perform the BH RLC channel addition/modification as specified in 5.3.5.5.11)
-    }
+  if( cellGroupConfig->ext2->bh_RLC_ChannelToReleaseList_r16 != NULL){
+    //TODO (perform the BH RLC channel addition/modification as specified in 5.3.5.5.11)
+  }
 
+  if( cellGroupConfig->ext2->bh_RLC_ChannelToAddModList_r16 != NULL){
+    //TODO (perform the BH RLC channel addition/modification as specified in 5.3.5.5.11)
+  }
 }
 
 /*--------------------------------------------------*/
 static void rrc_ue_generate_RRCSetupComplete(
-    const protocol_ctxt_t *const ctxt_pP,
-    const uint8_t gNB_index,
-    const uint8_t Transaction_id,
-    uint8_t sel_plmn_id){
-        uint8_t buffer[100];
-        uint8_t size;
-        const char *nas_msg;
-        int   nas_msg_length;
-       if (AMF_MODE_ENABLED) {
+  const protocol_ctxt_t *const ctxt_pP,
+  const uint8_t gNB_index,
+  const uint8_t Transaction_id,
+  uint8_t sel_plmn_id){
+  
+  uint8_t buffer[100];
+  uint8_t size;
+  const char *nas_msg;
+  int   nas_msg_length;
+ if (AMF_MODE_ENABLED) {
 #if ITTI_SIM
-          as_nas_info_t initialNasMsg;
-          generateRegistrationRequest(&initialNasMsg);
-          nas_msg = (char*)initialNasMsg.data;
-          nas_msg_length = initialNasMsg.length;
+    as_nas_info_t initialNasMsg;
+    generateRegistrationRequest(&initialNasMsg);
+    nas_msg = (char*)initialNasMsg.data;
+    nas_msg_length = initialNasMsg.length;
 #else
-          nas_msg         = (char *) NR_UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data;
-          nas_msg_length  = NR_UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.length;
+    nas_msg         = (char *) NR_UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data;
+    nas_msg_length  = NR_UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.length;
 #endif
-           } else {
-          nas_msg         = nr_nas_attach_req_imsi;
-          nas_msg_length  = sizeof(nr_nas_attach_req_imsi);
-       }
-       size = do_RRCSetupComplete(ctxt_pP->module_id,buffer,Transaction_id,sel_plmn_id,nas_msg_length,nas_msg);
-       LOG_I(NR_RRC,"[UE %d][RAPROC] Frame %d : Logical Channel UL-DCCH (SRB1), Generating RRCSetupComplete (bytes%d, gNB %d)\n",
-        ctxt_pP->module_id,ctxt_pP->frame, size, gNB_index);
-       LOG_D(RLC,
-            "[FRAME %05d][RRC_UE][MOD %02d][][--- PDCP_DATA_REQ/%d Bytes (RRCConnectionSetupComplete to gNB %d MUI %d) --->][PDCP][MOD %02d][RB %02d]\n",
-            ctxt_pP->frame, ctxt_pP->module_id+NB_RN_INST, size, gNB_index, nr_rrc_mui, ctxt_pP->module_id+NB_eNB_INST, DCCH);
-        // ctxt_pP_local.rnti = ctxt_pP->rnti;
-        rrc_data_req_ue(
-            ctxt_pP,
-            DCCH,
-            nr_rrc_mui++,
-            SDU_CONFIRM_NO,
-            size,
-            buffer,
-            PDCP_TRANSMISSION_MODE_CONTROL);
+  } else {
+    nas_msg         = nr_nas_attach_req_imsi;
+    nas_msg_length  = sizeof(nr_nas_attach_req_imsi);
+  }
+  size = do_RRCSetupComplete(ctxt_pP->module_id,buffer,Transaction_id,sel_plmn_id,nas_msg_length,nas_msg);
+  LOG_I(NR_RRC,"[UE %d][RAPROC] Frame %d : Logical Channel UL-DCCH (SRB1), Generating RRCSetupComplete (bytes%d, gNB %d)\n",
+   ctxt_pP->module_id,ctxt_pP->frame, size, gNB_index);
+  LOG_D(RLC,
+       "[FRAME %05d][RRC_UE][MOD %02d][][--- PDCP_DATA_REQ/%d Bytes (RRCConnectionSetupComplete to gNB %d MUI %d) --->][PDCP][MOD %02d][RB %02d]\n",
+       ctxt_pP->frame, ctxt_pP->module_id+NB_RN_INST, size, gNB_index, nr_rrc_mui, ctxt_pP->module_id+NB_eNB_INST, DCCH);
+   // ctxt_pP_local.rnti = ctxt_pP->rnti;
+  rrc_data_req_ue(
+      ctxt_pP,
+      DCCH,
+      nr_rrc_mui++,
+      SDU_CONFIRM_NO,
+      size,
+      buffer,
+      PDCP_TRANSMISSION_MODE_CONTROL);
 #ifdef ITTI_SIM
-        MessageDef *message_p;
-        uint8_t *message_buffer;
-        message_buffer = itti_malloc (TASK_RRC_UE_SIM, TASK_RRC_GNB_SIM, size);
-        memcpy (message_buffer, buffer, size);
-        message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, UE_RRC_DCCH_DATA_IND);
-        UE_RRC_DCCH_DATA_IND (message_p).rbid = 1;
-        UE_RRC_DCCH_DATA_IND (message_p).sdu = message_buffer;
-        UE_RRC_DCCH_DATA_IND (message_p).size  = size;
-        itti_send_msg_to_task (TASK_RRC_GNB_SIM, ctxt_pP->instance, message_p);
+  MessageDef *message_p;
+  uint8_t *message_buffer;
+  message_buffer = itti_malloc (TASK_RRC_UE_SIM, TASK_RRC_GNB_SIM, size);
+  memcpy (message_buffer, buffer, size);
+  message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, UE_RRC_DCCH_DATA_IND);
+  UE_RRC_DCCH_DATA_IND (message_p).rbid = 1;
+  UE_RRC_DCCH_DATA_IND (message_p).sdu = message_buffer;
+  UE_RRC_DCCH_DATA_IND (message_p).size  = size;
+  itti_send_msg_to_task (TASK_RRC_GNB_SIM, ctxt_pP->instance, message_p);
 #endif
 }
 
 int8_t nr_rrc_ue_decode_ccch( const protocol_ctxt_t *const ctxt_pP, const NR_SRB_INFO *const Srb_info, const uint8_t gNB_index ){
-    NR_DL_CCCH_Message_t *dl_ccch_msg=NULL;
-    asn_dec_rval_t dec_rval;
-    int rval=0;
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_IN);
-    //    LOG_D(RRC,"[UE %d] Decoding DL-CCCH message (%d bytes), State %d\n",ue_mod_idP,Srb_info->Rx_buffer.payload_size,
-    //    NR_UE_rrc_inst[ue_mod_idP].Info[gNB_index].State);
-    dec_rval = uper_decode(NULL,
-                           &asn_DEF_NR_DL_CCCH_Message,
-                           (void **)&dl_ccch_msg,
-                           (uint8_t *)Srb_info->Rx_buffer.Payload,
-                           100,0,0);
-    
-    // if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
-      xer_fprint(stdout,&asn_DEF_NR_DL_CCCH_Message,(void *)dl_ccch_msg);
-    // }
-    
-    if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) {
-      LOG_E(RRC,"[UE %d] Frame %d : Failed to decode DL-CCCH-Message (%zu bytes)\n",ctxt_pP->module_id,ctxt_pP->frame,dec_rval.consumed);
-      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
-      return -1;
-    }
-    
-    if (dl_ccch_msg->message.present == NR_DL_CCCH_MessageType_PR_c1) {
-      if (NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].State == NR_RRC_SI_RECEIVED) {
-        switch (dl_ccch_msg->message.choice.c1->present) {
-          case NR_DL_CCCH_MessageType__c1_PR_NOTHING:
-            LOG_I(NR_RRC, "[UE%d] Frame %d : Received PR_NOTHING on DL-CCCH-Message\n",
-                  ctxt_pP->module_id,
-                  ctxt_pP->frame);
-            rval = 0;
-            break;
-    
-          case NR_DL_CCCH_MessageType__c1_PR_rrcReject:
-            LOG_I(NR_RRC,
-                  "[UE%d] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionReject \n",
-                  ctxt_pP->module_id,
-                  ctxt_pP->frame);
-            rval = 0;
-            break;
-    
-          case NR_DL_CCCH_MessageType__c1_PR_rrcSetup:
-            LOG_I(NR_RRC,
-                  "[UE%d][RAPROC] Frame %d : Logical Channel DL-CCCH (SRB0), Received NR_RRCSetup RNTI %x\n",
-                  ctxt_pP->module_id,
-                  ctxt_pP->frame,
-                  ctxt_pP->rnti);
-            // Get configuration
-            // Release T300 timer
-            NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].T300_active = 0;
-            
-            nr_rrc_ue_process_masterCellGroup(
-              ctxt_pP,
-              gNB_index,
-              &dl_ccch_msg->message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup->masterCellGroup);
-            nr_sa_rrc_ue_process_radioBearerConfig(
-              ctxt_pP,
-              gNB_index,
-              &dl_ccch_msg->message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup->radioBearerConfig);
-            nr_rrc_set_state (ctxt_pP->module_id, RRC_STATE_CONNECTED);
-            nr_rrc_set_sub_state (ctxt_pP->module_id, RRC_SUB_STATE_CONNECTED);
-            NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].rnti = ctxt_pP->rnti;
-            rrc_ue_generate_RRCSetupComplete(
-              ctxt_pP,
-              gNB_index,
-              dl_ccch_msg->message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier,
-              NR_UE_rrc_inst[ctxt_pP->module_id].selected_plmn_identity);
-            rval = 0;
-            break;
-    
-          default:
-            LOG_E(NR_RRC, "[UE%d] Frame %d : Unknown message\n",
-                  ctxt_pP->module_id,
-                  ctxt_pP->frame);
-            rval = -1;
-            break;
-        }
+  NR_DL_CCCH_Message_t *dl_ccch_msg=NULL;
+  asn_dec_rval_t dec_rval;
+  int rval=0;
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_IN);
+  //    LOG_D(RRC,"[UE %d] Decoding DL-CCCH message (%d bytes), State %d\n",ue_mod_idP,Srb_info->Rx_buffer.payload_size,
+  //    NR_UE_rrc_inst[ue_mod_idP].Info[gNB_index].State);
+  dec_rval = uper_decode(NULL,
+                         &asn_DEF_NR_DL_CCCH_Message,
+                         (void **)&dl_ccch_msg,
+                         (uint8_t *)Srb_info->Rx_buffer.Payload,
+                         100,0,0);
+  
+  // if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
+    xer_fprint(stdout,&asn_DEF_NR_DL_CCCH_Message,(void *)dl_ccch_msg);
+  // }
+  
+  if ((dec_rval.code != RC_OK) && (dec_rval.consumed==0)) {
+    LOG_E(RRC,"[UE %d] Frame %d : Failed to decode DL-CCCH-Message (%zu bytes)\n",ctxt_pP->module_id,ctxt_pP->frame,dec_rval.consumed);
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
+    return -1;
+  }
+  
+  if (dl_ccch_msg->message.present == NR_DL_CCCH_MessageType_PR_c1) {
+    if (NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].State == NR_RRC_SI_RECEIVED) {
+      switch (dl_ccch_msg->message.choice.c1->present) {
+        case NR_DL_CCCH_MessageType__c1_PR_NOTHING:
+          LOG_I(NR_RRC, "[UE%d] Frame %d : Received PR_NOTHING on DL-CCCH-Message\n",
+                ctxt_pP->module_id,
+                ctxt_pP->frame);
+          rval = 0;
+          break;
+  
+        case NR_DL_CCCH_MessageType__c1_PR_rrcReject:
+          LOG_I(NR_RRC,
+                "[UE%d] Frame %d : Logical Channel DL-CCCH (SRB0), Received RRCConnectionReject \n",
+                ctxt_pP->module_id,
+                ctxt_pP->frame);
+          rval = 0;
+          break;
+  
+        case NR_DL_CCCH_MessageType__c1_PR_rrcSetup:
+          LOG_I(NR_RRC,
+                "[UE%d][RAPROC] Frame %d : Logical Channel DL-CCCH (SRB0), Received NR_RRCSetup RNTI %x\n",
+                ctxt_pP->module_id,
+                ctxt_pP->frame,
+                ctxt_pP->rnti);
+          // Get configuration
+          // Release T300 timer
+          NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].T300_active = 0;
+          
+          nr_rrc_ue_process_masterCellGroup(
+            ctxt_pP,
+            gNB_index,
+            &dl_ccch_msg->message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup->masterCellGroup);
+          nr_sa_rrc_ue_process_radioBearerConfig(
+            ctxt_pP,
+            gNB_index,
+            &dl_ccch_msg->message.choice.c1->choice.rrcSetup->criticalExtensions.choice.rrcSetup->radioBearerConfig);
+          nr_rrc_set_state (ctxt_pP->module_id, RRC_STATE_CONNECTED);
+          nr_rrc_set_sub_state (ctxt_pP->module_id, RRC_SUB_STATE_CONNECTED);
+          NR_UE_rrc_inst[ctxt_pP->module_id].Info[gNB_index].rnti = ctxt_pP->rnti;
+          rrc_ue_generate_RRCSetupComplete(
+            ctxt_pP,
+            gNB_index,
+            dl_ccch_msg->message.choice.c1->choice.rrcSetup->rrc_TransactionIdentifier,
+            NR_UE_rrc_inst[ctxt_pP->module_id].selected_plmn_identity);
+          rval = 0;
+          break;
+  
+        default:
+          LOG_E(NR_RRC, "[UE%d] Frame %d : Unknown message\n",
+                ctxt_pP->module_id,
+                ctxt_pP->frame);
+          rval = -1;
+          break;
       }
     }
-    
-    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
-    return rval;
-
+  }
+  
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_CCCH, VCD_FUNCTION_OUT);
+  return rval;
 }
 
 
 // from NR SRB3
 int8_t nr_rrc_ue_decode_NR_DL_DCCH_Message(
-    const module_id_t module_id,
-    const uint8_t     gNB_index,
-    const uint8_t    *bufferP,
-    const uint32_t    buffer_len ){
-    //  uper_decode by nr R15 rrc_connection_reconfiguration
-    
-    int32_t i;
-    NR_DL_DCCH_Message_t *nr_dl_dcch_msg = NULL;
-    MessageDef *msg_p;
-
-    asn_dec_rval_t dec_rval = uper_decode(  NULL,
-                                            &asn_DEF_NR_DL_DCCH_Message,    
-                                            (void**)&nr_dl_dcch_msg,
-                                            (uint8_t *)bufferP,
-                                            buffer_len, 0, 0);
+  const module_id_t module_id,
+  const uint8_t     gNB_index,
+  const uint8_t    *bufferP,
+  const uint32_t    buffer_len ){
+  //  uper_decode by nr R15 rrc_connection_reconfiguration
+  
+  int32_t i;
+  NR_DL_DCCH_Message_t *nr_dl_dcch_msg = NULL;
+  MessageDef *msg_p;
 
-    if ((dec_rval.code != RC_OK) || (dec_rval.consumed == 0)) {
+  asn_dec_rval_t dec_rval = uper_decode(  NULL,
+                                          &asn_DEF_NR_DL_DCCH_Message,    
+                                          (void**)&nr_dl_dcch_msg,
+                                          (uint8_t *)bufferP,
+                                          buffer_len, 0, 0);
 
-        for (i=0; i<buffer_len; i++)
-            printf("%02x ",bufferP[i]);
+  if ((dec_rval.code != RC_OK) || (dec_rval.consumed == 0)) {
+    for (i=0; i<buffer_len; i++)
+      printf("%02x ",bufferP[i]);
+    printf("\n");
+    // free the memory
+    SEQUENCE_free( &asn_DEF_NR_DL_DCCH_Message, (void *)nr_dl_dcch_msg, 1 );
+    return -1;
+  }
 
-        printf("\n");
-        // free the memory
-        SEQUENCE_free( &asn_DEF_NR_DL_DCCH_Message, (void *)nr_dl_dcch_msg, 1 );
-        return -1;
-    }
+  if(nr_dl_dcch_msg != NULL){
+    switch(nr_dl_dcch_msg->message.present){            
+      case NR_DL_DCCH_MessageType_PR_c1:
+        switch(nr_dl_dcch_msg->message.choice.c1->present){
+          case NR_DL_DCCH_MessageType__c1_PR_rrcReconfiguration:
+            nr_rrc_ue_process_rrcReconfiguration(module_id,nr_dl_dcch_msg->message.choice.c1->choice.rrcReconfiguration);
+            break;
 
-    if(nr_dl_dcch_msg != NULL){
-        switch(nr_dl_dcch_msg->message.present){            
-            case NR_DL_DCCH_MessageType_PR_c1:
-
-                switch(nr_dl_dcch_msg->message.choice.c1->present){
-                    case NR_DL_DCCH_MessageType__c1_PR_rrcReconfiguration:
-                        nr_rrc_ue_process_rrcReconfiguration(nr_dl_dcch_msg->message.choice.c1->choice.rrcReconfiguration);
-                        break;
-
-                    case NR_DL_DCCH_MessageType__c1_PR_NOTHING:
-                    case NR_DL_DCCH_MessageType__c1_PR_rrcResume:
-                    case NR_DL_DCCH_MessageType__c1_PR_rrcRelease:
-                        msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_CONN_RELEASE_IND);
-
-                        if((nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.present == NR_RRCRelease__criticalExtensions_PR_rrcRelease) &&
-                           (nr_dl_dcch_msg->message.choice.c1->present == NR_DL_DCCH_MessageType__c1_PR_rrcRelease)){
-                             nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationTimer =
-                             NR_RRCRelease_IEs__deprioritisationReq__deprioritisationTimer_min5;
-                             nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationType =
-                             NR_RRCRelease_IEs__deprioritisationReq__deprioritisationType_frequency;
-                           }
-			   itti_send_msg_to_task(TASK_RRC_NRUE,module_id,msg_p);
-                        break;
-                    case NR_DL_DCCH_MessageType__c1_PR_rrcReestablishment:
-                    case NR_DL_DCCH_MessageType__c1_PR_securityModeCommand:
-                    case NR_DL_DCCH_MessageType__c1_PR_dlInformationTransfer:
-                    case NR_DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
-                    case NR_DL_DCCH_MessageType__c1_PR_counterCheck:
-                    case NR_DL_DCCH_MessageType__c1_PR_mobilityFromNRCommand:
-                    case NR_DL_DCCH_MessageType__c1_PR_dlDedicatedMessageSegment_r16:
-                    case NR_DL_DCCH_MessageType__c1_PR_ueInformationRequest_r16:
-                    case NR_DL_DCCH_MessageType__c1_PR_dlInformationTransferMRDC_r16:
-                    case NR_DL_DCCH_MessageType__c1_PR_loggedMeasurementConfiguration_r16:
-                    case NR_DL_DCCH_MessageType__c1_PR_spare3:
-                    case NR_DL_DCCH_MessageType__c1_PR_spare2:
-                    case NR_DL_DCCH_MessageType__c1_PR_spare1:
-                    default:
-                        //  not supported or unused
-                        break;
-                }   
-                break;
-            case NR_DL_DCCH_MessageType_PR_NOTHING:
-            case NR_DL_DCCH_MessageType_PR_messageClassExtension:
-            default:
-                //  not supported or unused
-                break;
+          case NR_DL_DCCH_MessageType__c1_PR_NOTHING:
+          case NR_DL_DCCH_MessageType__c1_PR_rrcResume:
+          case NR_DL_DCCH_MessageType__c1_PR_rrcRelease:
+            msg_p = itti_alloc_new_message(TASK_RRC_NRUE, NAS_CONN_RELEASE_IND);
+            if((nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.present == NR_RRCRelease__criticalExtensions_PR_rrcRelease) &&
+               (nr_dl_dcch_msg->message.choice.c1->present == NR_DL_DCCH_MessageType__c1_PR_rrcRelease)){
+                nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationTimer =
+                NR_RRCRelease_IEs__deprioritisationReq__deprioritisationTimer_min5;
+                nr_dl_dcch_msg->message.choice.c1->choice.rrcRelease->criticalExtensions.choice.rrcRelease->deprioritisationReq->deprioritisationType =
+                NR_RRCRelease_IEs__deprioritisationReq__deprioritisationType_frequency;
+              }
+            itti_send_msg_to_task(TASK_RRC_NRUE,module_id,msg_p);
+            break;
+          
+          case NR_DL_DCCH_MessageType__c1_PR_rrcReestablishment:
+          case NR_DL_DCCH_MessageType__c1_PR_securityModeCommand:
+          case NR_DL_DCCH_MessageType__c1_PR_dlInformationTransfer:
+          case NR_DL_DCCH_MessageType__c1_PR_ueCapabilityEnquiry:
+          case NR_DL_DCCH_MessageType__c1_PR_counterCheck:
+          case NR_DL_DCCH_MessageType__c1_PR_mobilityFromNRCommand:
+          case NR_DL_DCCH_MessageType__c1_PR_dlDedicatedMessageSegment_r16:
+          case NR_DL_DCCH_MessageType__c1_PR_ueInformationRequest_r16:
+          case NR_DL_DCCH_MessageType__c1_PR_dlInformationTransferMRDC_r16:
+          case NR_DL_DCCH_MessageType__c1_PR_loggedMeasurementConfiguration_r16:
+          case NR_DL_DCCH_MessageType__c1_PR_spare3:
+          case NR_DL_DCCH_MessageType__c1_PR_spare2:
+          case NR_DL_DCCH_MessageType__c1_PR_spare1:
+          default:
+            //  not supported or unused
+            break;
         }
-        
-        //  release memory allocation
-        SEQUENCE_free( &asn_DEF_NR_DL_DCCH_Message, (void *)nr_dl_dcch_msg, 1 );
-    }else{
-        //  log..
+        break;
+      case NR_DL_DCCH_MessageType_PR_NOTHING:
+      case NR_DL_DCCH_MessageType_PR_messageClassExtension:
+      default:
+        //  not supported or unused
+        break;
     }
+    
+    //  release memory allocation
+    SEQUENCE_free( &asn_DEF_NR_DL_DCCH_Message, (void *)nr_dl_dcch_msg, 1 );
+  }else{
+    //  log..
+  }
 
-    return 0;
-
+  return 0;
 }
 
 
@@ -1628,11 +1620,11 @@ nr_rrc_ue_process_securityModeCommand(
   }
 
   LOG_D(NR_RRC,"[UE %d] security mode is %x \n",ctxt_pP->module_id, securityMode);
-  NR_UE_rrc_inst->cipheringAlgorithm =
+  NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm =
     securityModeCommand->criticalExtensions.choice.securityModeCommand->securityConfigSMC.securityAlgorithmConfig.cipheringAlgorithm;
-  NR_UE_rrc_inst->integrityProtAlgorithm =
+  NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm =
     *securityModeCommand->criticalExtensions.choice.securityModeCommand->securityConfigSMC.securityAlgorithmConfig.integrityProtAlgorithm;
-memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
+  memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
   //memset((void *)&SecurityModeCommand,0,sizeof(SecurityModeCommand_t));
   ul_dcch_msg.message.present           = NR_UL_DCCH_MessageType_PR_c1;
   ul_dcch_msg.message.choice.c1         = calloc(1, sizeof(*ul_dcch_msg.message.choice.c1));
@@ -1666,22 +1658,22 @@ memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
           "%02x%02x%02x%02x"
           "%02x%02x%02x%02x"
           "%02x%02x%02x%02x\n",
-          NR_UE_rrc_inst->kgnb[0],  NR_UE_rrc_inst->kgnb[1],  NR_UE_rrc_inst->kgnb[2],  NR_UE_rrc_inst->kgnb[3],
-          NR_UE_rrc_inst->kgnb[4],  NR_UE_rrc_inst->kgnb[5],  NR_UE_rrc_inst->kgnb[6],  NR_UE_rrc_inst->kgnb[7],
-          NR_UE_rrc_inst->kgnb[8],  NR_UE_rrc_inst->kgnb[9],  NR_UE_rrc_inst->kgnb[10], NR_UE_rrc_inst->kgnb[11],
-          NR_UE_rrc_inst->kgnb[12], NR_UE_rrc_inst->kgnb[13], NR_UE_rrc_inst->kgnb[14], NR_UE_rrc_inst->kgnb[15],
-          NR_UE_rrc_inst->kgnb[16], NR_UE_rrc_inst->kgnb[17], NR_UE_rrc_inst->kgnb[18], NR_UE_rrc_inst->kgnb[19],
-          NR_UE_rrc_inst->kgnb[20], NR_UE_rrc_inst->kgnb[21], NR_UE_rrc_inst->kgnb[22], NR_UE_rrc_inst->kgnb[23],
-          NR_UE_rrc_inst->kgnb[24], NR_UE_rrc_inst->kgnb[25], NR_UE_rrc_inst->kgnb[26], NR_UE_rrc_inst->kgnb[27],
-          NR_UE_rrc_inst->kgnb[28], NR_UE_rrc_inst->kgnb[29], NR_UE_rrc_inst->kgnb[30], NR_UE_rrc_inst->kgnb[31]);
-    derive_key_rrc_enc(NR_UE_rrc_inst->cipheringAlgorithm,NR_UE_rrc_inst->kgnb, &kRRCenc);
-    derive_key_rrc_int(NR_UE_rrc_inst->integrityProtAlgorithm,NR_UE_rrc_inst->kgnb, &kRRCint);
-    derive_key_up_enc(NR_UE_rrc_inst->cipheringAlgorithm,NR_UE_rrc_inst->kgnb, &kUPenc);
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[0],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[1],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[2],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[3],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[4],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[5],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[6],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[7],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[8],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[9],  NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[10], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[11],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[12], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[13], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[14], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[15],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[16], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[17], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[18], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[19],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[20], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[21], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[22], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[23],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[24], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[25], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[26], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[27],
+          NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[28], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[29], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[30], NR_UE_rrc_inst[ctxt_pP->module_id].kgnb[31]);
+    derive_key_rrc_enc(NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm,NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCenc);
+    derive_key_rrc_int(NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm,NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCint);
+    derive_key_up_enc(NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm,NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kUPenc);
 
     if (securityMode != 0xff) {
       pdcp_config_set_security(ctxt_pP, pdcp_p, 0, 0,
-                               NR_UE_rrc_inst->cipheringAlgorithm
-                               | (NR_UE_rrc_inst->integrityProtAlgorithm << 4),
+                               NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm
+                               | (NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm << 4),
                                kRRCenc, kRRCint, kUPenc);
     } else {
       LOG_I(NR_RRC, "skipped pdcp_config_set_security() as securityMode == 0x%02x",
@@ -1696,7 +1688,7 @@ memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
     ul_dcch_msg.message.choice.c1->choice.securityModeComplete->rrc_TransactionIdentifier = securityModeCommand->rrc_TransactionIdentifier;
     ul_dcch_msg.message.choice.c1->choice.securityModeComplete->criticalExtensions.present = NR_SecurityModeComplete__criticalExtensions_PR_securityModeComplete;
     ul_dcch_msg.message.choice.c1->choice.securityModeComplete->criticalExtensions.choice.securityModeComplete = CALLOC(1, sizeof(NR_SecurityModeComplete_IEs_t));
-	ul_dcch_msg.message.choice.c1->choice.securityModeComplete->criticalExtensions.choice.securityModeComplete->nonCriticalExtension =NULL;
+    ul_dcch_msg.message.choice.c1->choice.securityModeComplete->criticalExtensions.choice.securityModeComplete->nonCriticalExtension =NULL;
     LOG_I(NR_RRC,"[UE %d] SFN/SF %d/%d: Receiving from SRB1 (DL-DCCH), encoding securityModeComplete (gNB %d), rrc_TransactionIdentifier: %ld\n",
           ctxt_pP->module_id,ctxt_pP->frame, ctxt_pP->subframe, gNB_index, securityModeCommand->rrc_TransactionIdentifier);
     enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UL_DCCH_Message,
@@ -1719,17 +1711,17 @@ memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
 
     LOG_T(NR_RRC, "\n");
 #ifdef ITTI_SIM
-		MessageDef *message_p;
-		uint8_t *message_buffer;
-		message_buffer = itti_malloc (TASK_RRC_UE_SIM,TASK_RRC_GNB_SIM,
-						   (enc_rval.encoded + 7) / 8);
-		memcpy (message_buffer, buffer, (enc_rval.encoded + 7) / 8);
-
-		message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, UE_RRC_DCCH_DATA_IND);
-		GNB_RRC_DCCH_DATA_IND (message_p).rbid  = DCCH;
-		GNB_RRC_DCCH_DATA_IND (message_p).sdu   = message_buffer;
-		GNB_RRC_DCCH_DATA_IND (message_p).size	= (enc_rval.encoded + 7) / 8;
-		itti_send_msg_to_task (TASK_RRC_GNB_SIM, ctxt_pP->instance, message_p);
+    MessageDef *message_p;
+    uint8_t *message_buffer;
+    message_buffer = itti_malloc (TASK_RRC_UE_SIM,TASK_RRC_GNB_SIM,
+                       (enc_rval.encoded + 7) / 8);
+    memcpy (message_buffer, buffer, (enc_rval.encoded + 7) / 8);
+
+    message_p = itti_alloc_new_message (TASK_RRC_UE_SIM, UE_RRC_DCCH_DATA_IND);
+    GNB_RRC_DCCH_DATA_IND (message_p).rbid  = DCCH;
+    GNB_RRC_DCCH_DATA_IND (message_p).sdu   = message_buffer;
+    GNB_RRC_DCCH_DATA_IND (message_p).size    = (enc_rval.encoded + 7) / 8;
+    itti_send_msg_to_task (TASK_RRC_GNB_SIM, ctxt_pP->instance, message_p);
 #else
     rrc_data_req (
       ctxt_pP,
@@ -1740,7 +1732,8 @@ memset((void *)&ul_dcch_msg,0,sizeof(NR_UL_DCCH_Message_t));
       buffer,
       PDCP_TRANSMISSION_MODE_CONTROL);
 #endif
-  } else LOG_W(NR_RRC,"securityModeCommand->criticalExtensions.present (%d) != NR_SecurityModeCommand__criticalExtensions_PR_securityModeCommand\n",
+  } else
+    LOG_W(NR_RRC,"securityModeCommand->criticalExtensions.present (%d) != NR_SecurityModeCommand__criticalExtensions_PR_securityModeCommand\n",
                  securityModeCommand->criticalExtensions.present);
 }
 
@@ -1803,12 +1796,12 @@ nr_rrc_ue_establish_srb1(
 )
 //-----------------------------------------------------------------------------
 {
-    // add descriptor from RRC PDU
-    NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Active = 1;
-    NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Status = RADIO_CONFIG_OK;//RADIO CFG
-    NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Srb_info.Srb_id = 1;
-    LOG_I(NR_RRC, "[UE %d], CONFIG_SRB1 %d corresponding to gNB_index %d\n", ue_mod_idP, DCCH, gNB_index);
-    return(0);
+  // add descriptor from RRC PDU
+  NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Active = 1;
+  NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Status = RADIO_CONFIG_OK;//RADIO CFG
+  NR_UE_rrc_inst[ue_mod_idP].Srb1[gNB_index].Srb_info.Srb_id = 1;
+  LOG_I(NR_RRC, "[UE %d], CONFIG_SRB1 %d corresponding to gNB_index %d\n", ue_mod_idP, DCCH, gNB_index);
+  return(0);
 }
 
 //-----------------------------------------------------------------------------
@@ -1848,31 +1841,31 @@ nr_rrc_ue_establish_drb(
   LOG_I(NR_RRC,"[UE %d] Frame %d: processing RRCReconfiguration: reconfiguring DRB %ld\n",
         ue_mod_idP, frameP, DRB_config->drb_Identity);
 
-   if(!AMF_MODE_ENABLED) {
-    ip_addr_offset3 = 0;
-    ip_addr_offset4 = 1;
-    LOG_I(OIP, "[UE %d] trying to bring up the OAI interface %d, IP X.Y.%d.%d\n", ue_mod_idP, ip_addr_offset3+ue_mod_idP,
-          ip_addr_offset3+ue_mod_idP+1, ip_addr_offset4+ue_mod_idP+1);
-    oip_ifup = nas_config(ip_addr_offset3+ue_mod_idP+1,   // interface_id
-                        UE_NAS_USE_TUN?1:(ip_addr_offset3+ue_mod_idP+1), // third_octet
-                        ip_addr_offset4+ue_mod_idP+1, // fourth_octet
-                        "oip");                        // interface suffix (when using kernel module)
-
-    if (oip_ifup == 0 && (!UE_NAS_USE_TUN)) { // interface is up --> send a config the DRB
-      LOG_I(OIP, "[UE %d] Config the ue net interface %d to send/receive pkt on DRB %ld to/from the protocol stack\n",
-            ue_mod_idP,
-            ip_addr_offset3+ue_mod_idP,
-            (long int)((gNB_index * NR_maxDRB) + DRB_config->drb_Identity));
-      rb_conf_ipv4(0,//add
-                   ue_mod_idP,//cx align with the UE index
-                   ip_addr_offset3+ue_mod_idP,//inst num_enb+ue_index
-                   (gNB_index * NR_maxDRB) + DRB_config->drb_Identity,//rb
-                   0,//dscp
-                   ipv4_address(ip_addr_offset3+ue_mod_idP+1, ip_addr_offset4+ue_mod_idP+1),//saddr
-                   ipv4_address(ip_addr_offset3+ue_mod_idP+1, gNB_index+1));//daddr
-      LOG_D(NR_RRC,"[UE %d] State = Attached (gNB %d)\n",ue_mod_idP,gNB_index);
-    }
+ if(!AMF_MODE_ENABLED) {
+   ip_addr_offset3 = 0;
+   ip_addr_offset4 = 1;
+   LOG_I(OIP, "[UE %d] trying to bring up the OAI interface %d, IP X.Y.%d.%d\n", ue_mod_idP, ip_addr_offset3+ue_mod_idP,
+         ip_addr_offset3+ue_mod_idP+1, ip_addr_offset4+ue_mod_idP+1);
+   oip_ifup = nas_config(ip_addr_offset3+ue_mod_idP+1,   // interface_id
+                       UE_NAS_USE_TUN?1:(ip_addr_offset3+ue_mod_idP+1), // third_octet
+                       ip_addr_offset4+ue_mod_idP+1, // fourth_octet
+                       "oip");                        // interface suffix (when using kernel module)
+
+   if (oip_ifup == 0 && (!UE_NAS_USE_TUN)) { // interface is up --> send a config the DRB
+     LOG_I(OIP, "[UE %d] Config the ue net interface %d to send/receive pkt on DRB %ld to/from the protocol stack\n",
+           ue_mod_idP,
+           ip_addr_offset3+ue_mod_idP,
+           (long int)((gNB_index * NR_maxDRB) + DRB_config->drb_Identity));
+     rb_conf_ipv4(0,//add
+                  ue_mod_idP,//cx align with the UE index
+                  ip_addr_offset3+ue_mod_idP,//inst num_enb+ue_index
+                  (gNB_index * NR_maxDRB) + DRB_config->drb_Identity,//rb
+                  0,//dscp
+                  ipv4_address(ip_addr_offset3+ue_mod_idP+1, ip_addr_offset4+ue_mod_idP+1),//saddr
+                  ipv4_address(ip_addr_offset3+ue_mod_idP+1, gNB_index+1));//daddr
+     LOG_D(NR_RRC,"[UE %d] State = Attached (gNB %d)\n",ue_mod_idP,gNB_index);
    }
+ }
 
   return(0);
 }
@@ -2020,79 +2013,78 @@ nr_sa_rrc_ue_process_radioBearerConfig(
   }
 
   if (radioBearerConfig->srb_ToAddModList != NULL) {
-
-      if (radioBearerConfig->securityConfig != NULL) {
-          if (*radioBearerConfig->securityConfig->keyToUse == NR_SecurityConfig__keyToUse_master) {
-              NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm =
-                  radioBearerConfig->securityConfig->securityAlgorithmConfig->cipheringAlgorithm;
-              NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm =
-                  *radioBearerConfig->securityConfig->securityAlgorithmConfig->integrityProtAlgorithm;
-          }
+    if (radioBearerConfig->securityConfig != NULL) {
+      if (*radioBearerConfig->securityConfig->keyToUse == NR_SecurityConfig__keyToUse_master) {
+        NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm =
+            radioBearerConfig->securityConfig->securityAlgorithmConfig->cipheringAlgorithm;
+        NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm =
+            *radioBearerConfig->securityConfig->securityAlgorithmConfig->integrityProtAlgorithm;
       }
+    }
 
-      uint8_t *kRRCenc = NULL;
-      uint8_t *kRRCint = NULL;
-      derive_key_rrc_enc(NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm,
-                      NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCenc);
-      derive_key_rrc_int(NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm,
-                      NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCint);
-      // Refresh SRBs
-      // nr_rrc_pdcp_config_asn1_req(ctxt_pP,
-      //                             radioBearerConfig->srb_ToAddModList,
-      //                             NULL,
-      //                             NULL,
-      //                             NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm |
-      //                             (NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm << 4),
-      //                             kRRCenc,
-      //                             kRRCint,
-      //                             NULL,
-      //                             NULL,
-      //                             NULL,
-      //                             NULL);
-      // Refresh SRBs
-      // nr_rrc_rlc_config_asn1_req(ctxt_pP,
-      //                             radioBearerConfig->srb_ToAddModList,
-      //                             NULL,
-      //                             NULL,
-      //                             NULL,
-      //                             NULL
-      //                             );
-
-      for (cnt = 0; cnt < radioBearerConfig->srb_ToAddModList->list.count; cnt++) {
-          SRB_id = radioBearerConfig->srb_ToAddModList->list.array[cnt]->srb_Identity;
-          LOG_D(NR_RRC,"[UE %d]: Frame %d SRB config cnt %d (SRB%ld)\n", ctxt_pP->module_id, ctxt_pP->frame, cnt, SRB_id);
-          if (SRB_id == 1) {
-              if (NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index]) {
-                  memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index],
-                      radioBearerConfig->srb_ToAddModList->list.array[cnt], sizeof(NR_SRB_ToAddMod_t));
-              } else {
-                  NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index] = radioBearerConfig->srb_ToAddModList->list.array[cnt];
-                  nr_rrc_ue_establish_srb1(ctxt_pP->module_id,
-                                          ctxt_pP->frame,
-                                          gNB_index,
-                                          radioBearerConfig->srb_ToAddModList->list.array[cnt]);
-
-                  LOG_I(NR_RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB1 gNB %d) --->][MAC_UE][MOD %02d][]\n",
-                      ctxt_pP->frame, ctxt_pP->module_id, gNB_index, ctxt_pP->module_id);
-                  // rrc_mac_config_req_ue
-              }
-          } else {
-              if (NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index]) {
-                  memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index],
-                      radioBearerConfig->srb_ToAddModList->list.array[cnt], sizeof(NR_SRB_ToAddMod_t));
-              } else {
-                  NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index] = radioBearerConfig->srb_ToAddModList->list.array[cnt];
-                  nr_rrc_ue_establish_srb2(ctxt_pP->module_id,
-                                          ctxt_pP->frame,
-                                          gNB_index,
-                                          radioBearerConfig->srb_ToAddModList->list.array[cnt]);
-
-                  LOG_I(NR_RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB2 gNB %d) --->][MAC_UE][MOD %02d][]\n",
-                      ctxt_pP->frame, ctxt_pP->module_id, gNB_index, ctxt_pP->module_id);
-                  // rrc_mac_config_req_ue
-              }
-          } // srb2
-      }
+    uint8_t *kRRCenc = NULL;
+    uint8_t *kRRCint = NULL;
+    derive_key_rrc_enc(NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm,
+                    NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCenc);
+    derive_key_rrc_int(NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm,
+                    NR_UE_rrc_inst[ctxt_pP->module_id].kgnb, &kRRCint);
+    // Refresh SRBs
+    // nr_rrc_pdcp_config_asn1_req(ctxt_pP,
+    //                             radioBearerConfig->srb_ToAddModList,
+    //                             NULL,
+    //                             NULL,
+    //                             NR_UE_rrc_inst[ctxt_pP->module_id].cipheringAlgorithm |
+    //                             (NR_UE_rrc_inst[ctxt_pP->module_id].integrityProtAlgorithm << 4),
+    //                             kRRCenc,
+    //                             kRRCint,
+    //                             NULL,
+    //                             NULL,
+    //                             NULL,
+    //                             NULL);
+    // Refresh SRBs
+    // nr_rrc_rlc_config_asn1_req(ctxt_pP,
+    //                             radioBearerConfig->srb_ToAddModList,
+    //                             NULL,
+    //                             NULL,
+    //                             NULL,
+    //                             NULL
+    //                             );
+
+    for (cnt = 0; cnt < radioBearerConfig->srb_ToAddModList->list.count; cnt++) {
+      SRB_id = radioBearerConfig->srb_ToAddModList->list.array[cnt]->srb_Identity;
+      LOG_D(NR_RRC,"[UE %d]: Frame %d SRB config cnt %d (SRB%ld)\n", ctxt_pP->module_id, ctxt_pP->frame, cnt, SRB_id);
+      if (SRB_id == 1) {
+        if (NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index]) {
+          memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index],
+              radioBearerConfig->srb_ToAddModList->list.array[cnt], sizeof(NR_SRB_ToAddMod_t));
+        } else {
+          NR_UE_rrc_inst[ctxt_pP->module_id].SRB1_config[gNB_index] = radioBearerConfig->srb_ToAddModList->list.array[cnt];
+          nr_rrc_ue_establish_srb1(ctxt_pP->module_id,
+                                  ctxt_pP->frame,
+                                  gNB_index,
+                                  radioBearerConfig->srb_ToAddModList->list.array[cnt]);
+
+          LOG_I(NR_RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB1 gNB %d) --->][MAC_UE][MOD %02d][]\n",
+              ctxt_pP->frame, ctxt_pP->module_id, gNB_index, ctxt_pP->module_id);
+          // rrc_mac_config_req_ue
+        }
+      } else {
+        if (NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index]) {
+          memcpy(NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index],
+              radioBearerConfig->srb_ToAddModList->list.array[cnt], sizeof(NR_SRB_ToAddMod_t));
+        } else {
+          NR_UE_rrc_inst[ctxt_pP->module_id].SRB2_config[gNB_index] = radioBearerConfig->srb_ToAddModList->list.array[cnt];
+          nr_rrc_ue_establish_srb2(ctxt_pP->module_id,
+                                  ctxt_pP->frame,
+                                  gNB_index,
+                                  radioBearerConfig->srb_ToAddModList->list.array[cnt]);
+
+          LOG_I(NR_RRC, "[FRAME %05d][RRC_UE][MOD %02d][][--- MAC_CONFIG_REQ  (SRB2 gNB %d) --->][MAC_UE][MOD %02d][]\n",
+              ctxt_pP->frame, ctxt_pP->module_id, gNB_index, ctxt_pP->module_id);
+          // rrc_mac_config_req_ue
+        }
+      } // srb2
+    }
   } // srb_ToAddModList
 
   // Establish DRBs if present
@@ -2435,7 +2427,7 @@ void *rrc_nrue_task( void *args_p ) {
         LOG_E(NR_RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p));
         break;
     }
-	LOG_I(NR_RRC, "[UE %d] RRC Status %d\n", ue_mod_id, nr_rrc_get_state(ue_mod_id));
+    LOG_I(NR_RRC, "[UE %d] RRC Status %d\n", ue_mod_id, nr_rrc_get_state(ue_mod_id));
     result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
     AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
     msg_p = NULL;

openair2/RRC/NR_UE/rrc_proto.h

@@ -59,12 +59,12 @@ NR_UE_RRC_INST_t* openair_rrc_top_init_ue_nr(char*);
    \param size    length of buffer*/
 //TODO check to use which one
 //int8_t nr_rrc_ue_decode_rrcReconfiguration(const uint8_t *buffer, const uint32_t size);
-int8_t nr_rrc_ue_decode_secondary_cellgroup_config(const uint8_t *buffer, const uint32_t size);
+int8_t nr_rrc_ue_decode_secondary_cellgroup_config(const module_id_t module_id, const uint8_t *buffer, const uint32_t size);
    
 
 /**\brief Process NR RRC connection reconfiguration via SRB3
    \param rrcReconfiguration  decoded rrc connection reconfiguration*/
-int8_t nr_rrc_ue_process_rrcReconfiguration(NR_RRCReconfiguration_t *rrcReconfiguration);
+int8_t nr_rrc_ue_process_rrcReconfiguration(const module_id_t module_id, NR_RRCReconfiguration_t *rrcReconfiguration);
 
 /**\prief Process measurement config from NR RRC connection reconfiguration message
    \param meas_config   measurement configuration*/
@@ -73,7 +73,7 @@ int8_t nr_rrc_ue_process_meas_config(NR_MeasConfig_t *meas_config);
 /**\prief Process secondary cell group config from NR RRC connection reconfiguration message or EN-DC primitives
    \param cell_group_config   secondary cell group configuration*/
 //TODO check EN-DC function call flow.
-int8_t nr_rrc_ue_process_scg_config(NR_CellGroupConfig_t *cell_group_config);
+int8_t nr_rrc_ue_process_scg_config(const module_id_t module_id, NR_CellGroupConfig_t *cell_group_config);
 
 /**\prief Process radio bearer config from NR RRC connection reconfiguration message
    \param radio_bearer_config    radio bearer configuration*/

targets/COMMON/openairinterface5g_limits.h

@@ -20,7 +20,8 @@
 #                    define NUMBER_OF_CONNECTED_gNB_MAX 1
 #            endif
 #        else
-#                    define NUMBER_OF_UE_MAX 1
+#                    define NUMBER_OF_UE_MAX 4
+#                    define NUMBER_OF_NR_UE_MAX 4
 #                    define NUMBER_OF_UCI_VARS_MAX 56
 #                    define NUMBER_OF_CONNECTED_eNB_MAX 1
 #                    define NUMBER_OF_CONNECTED_gNB_MAX 1