Have completed full NSA procedure once.

At the moment, the NSA mode worked once, but shows
unpredictable behavior. Other times it does not work.
In this commit I added several LOG_A messages for NSA
mode. Also removed old comments that were added during
development. Lastly, more comments for all the hacks
have been added.

openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c

@@ -145,7 +145,7 @@ static void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request)
         nfapi_nr_dl_tti_request_pdu_t *pdu_list = &dl_tti_request->dl_tti_request_body.dl_tti_pdu_list[i];
         if (pdu_list->PDUType == NFAPI_NR_DL_TTI_SSB_PDU_TYPE)
         {
-            LOG_I(NR_PHY, "Cell_id: %d, the ssb_block_idx %d, sc_offset: %d and payload %d\n",
+            LOG_D(NR_PHY, "Cell_id: %d, the ssb_block_idx %d, sc_offset: %d and payload %d\n",
                 pdu_list->ssb_pdu.ssb_pdu_rel15.PhysCellId,
                 pdu_list->ssb_pdu.ssb_pdu_rel15.SsbBlockIndex,
                 pdu_list->ssb_pdu.ssb_pdu_rel15.SsbSubcarrierOffset,
@@ -163,8 +163,8 @@ static void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request)
     {
         LOG_E(NR_PHY, "%s: Error packing nr p7 message.\n", __FUNCTION__);
     }
-    LOG_I(NR_RRC, "Calling nsa_sendmsg_to_lte_ue to send a NR_UE_RRC_MEASUREMENT\n");
     nsa_sendmsg_to_lte_ue(buffer, pack_len, NR_UE_RRC_MEASUREMENT);
+    LOG_A(NR_RRC, "Populated NR_UE_RRC_MEASUREMENT information and sent to LTE UE\n");
 }
 
 void *nrue_standalone_pnf_task(void *context)
@@ -228,10 +228,10 @@ void *nrue_standalone_pnf_task(void *context)
             save_nr_measurement_info(&dl_tti_request);
             break;
           case NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST:
-            LOG_I(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST message. \n");
+            LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_TX_DATA_REQUEST message. \n");
             break;
           case NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST:
-            LOG_I(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST message. \n");
+            LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_DCI_REQUEST message. \n");
             break;
           case NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST:
             LOG_D(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST message. \n");

openair2/RRC/LTE/MESSAGES/asn1_msg.c

@@ -2415,8 +2415,6 @@ do_RRCConnectionReconfigurationComplete(
 )
 //------------------------------------------------------------------------------
 {
-  LOG_I(RRC, "Melissa, entered do_RRCConnectionReconfigurationComplete \n");
-
   asn_enc_rval_t enc_rval;
   LTE_UL_DCCH_Message_t ul_dcch_msg;
   LTE_RRCConnectionReconfigurationComplete_t *rrcConnectionReconfigurationComplete;
@@ -2429,7 +2427,7 @@ do_RRCConnectionReconfigurationComplete(
     LTE_RRCConnectionReconfigurationComplete__criticalExtensions_PR_rrcConnectionReconfigurationComplete_r8;
   if (str != NULL) {
     assign_scg_ConfigResponseNR_r15(rrcConnectionReconfigurationComplete, str);
-    LOG_I(RRC, "Melissa we finished assign_scg_ConfigResponseNR_r15\n");
+    LOG_D(RRC, "Successfully assigned scg_ConfigResponseNR_r15\n");
   }
   else {
     rrcConnectionReconfigurationComplete->criticalExtensions.choice.rrcConnectionReconfigurationComplete_r8.nonCriticalExtension=NULL;

openair2/RRC/LTE/rrc_UE.c

@@ -98,6 +98,8 @@ static int from_nr_ue_fd = -1;
 static int to_nr_ue_fd = -1;
 int slrb_id;
 int send_ue_information = 0;
+/* Melissa, this is a hack. Just created a ctxt global. Need to pass to process_nr_nsa_msg(). */
+protocol_ctxt_t ctxt_g;
 
 // for malloc_clear
 #include "PHY/defs_UE.h"
@@ -571,7 +573,6 @@ void rrc_ue_generate_RRCConnectionReconfigurationComplete(const protocol_ctxt_t
                                                           const uint8_t Transaction_id,
                                                           OCTET_STRING_t *str) {
   uint8_t buffer[RRC_BUF_SIZE];
-  LOG_I(RRC, "Melissa, calling do_RRCConnectionReconfigurationComplete \n");
   size_t size = do_RRCConnectionReconfigurationComplete(ctxt_pP, buffer, sizeof(buffer), Transaction_id, str);
   LOG_I(RRC,PROTOCOL_RRC_CTXT_UE_FMT" Logical Channel UL-DCCH (SRB1), Generating RRCConnectionReconfigurationComplete (bytes %zu, eNB_index %d)\n",
         PROTOCOL_RRC_CTXT_UE_ARGS(ctxt_pP), size, eNB_index);
@@ -847,8 +848,9 @@ rrc_ue_process_measConfig(
                                                             sizeof(buffer));
             AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %zu)!\n",
                           enc_rval.failed_type->name, enc_rval.encoded);
-            LOG_I(RRC, "Calling nsa_sendmsg_to_nr_ue to send a RRC_MEASUREMENT_PROCEDURE\n");
             nsa_sendmsg_to_nrue(buffer, (enc_rval.encoded + 7)/8, RRC_MEASUREMENT_PROCEDURE);
+            LOG_A(RRC, "Encoded measurement object %zu bits (%zu bytes) and sent to NR UE\n",
+                  enc_rval.encoded, (enc_rval.encoded + 7)/8);
           }
           LOG_D(RRC, "Adding measurement object [%d][%ld]\n", eNB_index, ind);
           ue->MeasObj[eNB_index][ind-1]=measObj;
@@ -1952,9 +1954,9 @@ rrc_ue_process_rrcConnectionReconfiguration(
                       nr_RadioBearer->size,
                       nr_SecondaryCellGroup->size);
 
-          LOG_I(RRC, "Calling nsa_sendmsg_to_nr_ue to send an RRC_CONFIG_COMPLETE_REQ\n");
           nsa_sendmsg_to_nrue(&msg, sizeof(msg), RRC_CONFIG_COMPLETE_REQ);
-          #if 0
+          LOG_A(RRC, "Sent RRC_CONFIG_COMPLETE_REQ to the NR UE\n");
+          #if 0 //Melissa, this is a hack. We need the transaction_id from latest dl_dcch_msg the LTE UE received. (Ln 6658)
           LTE_RRCConnectionReconfiguration_t *rrc = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].dl_dcch_msg->message.
                                                     choice.c1.choice.rrcConnectionReconfiguration;
           if (rrc != NULL) {
@@ -2485,6 +2487,8 @@ rrc_ue_decode_dcch(
                                       nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
                                       nonCriticalExtension->requestedFreqBandsNR_MRDC_r15;
                 nsa_sendmsg_to_nrue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, NRUE_CAPABILITY_ENQUIRY);
+                LOG_A(RRC, "Second ueCapabilityEnquiry (request for NR capabilities) sent to NR UE with size %zu\n",
+                      requestedFreqBandsNR->size);
                 // Save ueCapabilityEnquiry so we can use in nsa mode after nrUE response is received
                 UE_RRC_INFO *info = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP];
                 if (info->dl_dcch_msg != NULL) {
@@ -2499,6 +2503,7 @@ rrc_ue_decode_dcch(
                                     nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
                                     nonCriticalExtension->requestedFreqBandsNR_MRDC_r15;
               nsa_sendmsg_to_nrue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, UE_CAPABILITY_ENQUIRY);
+              LOG_A(RRC, "Initial ueCapabilityEnquiry sent to NR UE with size %zu\n", requestedFreqBandsNR->size);
               // Save ueCapabilityEnquiry so we can use in nsa mode after nrUE response is received
               UE_RRC_INFO *info = &UE_rrc_inst[ctxt_pP->module_id].Info[eNB_indexP];
               if (info->dl_dcch_msg != NULL) {
@@ -4864,6 +4869,7 @@ void *rrc_ue_task( void *args_p ) {
     itti_receive_msg (TASK_RRC_UE, &msg_p);
     instance = ITTI_MSG_DESTINATION_INSTANCE (msg_p);
     ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
+    ctxt_g = ctxt;
 
     /* TODO: Add case to handle nr-UE messages we want from nrUE RRC layer */
     switch (ITTI_MSG_ID(msg_p)) {
@@ -6541,8 +6547,6 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
     uint8_t *const msg_buffer = msg->msg_buffer;
     msg_len -= sizeof(msg->msg_type);
     bool received_nr_msg = true;
-    protocol_ctxt_t ctxt;
-    memset(&ctxt, 0, sizeof(ctxt));
 
     switch (msg_type)
     {
@@ -6557,7 +6561,7 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             AssertFatal(msg_len <= sizeof(nrue_cap_buf->mesg), "msg_len = %d\n", msg_len);
             memcpy(nrue_cap_buf->mesg, msg_buffer, msg_len);
             nrue_cap_buf->mesg_len = msg_len;
-            UE_RRC_INFO *info = &UE_rrc_inst[ctxt.module_id].Info[0];
+            UE_RRC_INFO *info = &UE_rrc_inst[ctxt_g.module_id].Info[0];
             nrue_cap_buf->dl_dcch_msg = info->dl_dcch_msg;
             info->dl_dcch_msg = NULL;
             message_p = itti_alloc_new_message (TASK_RRC_UE, 0, RRC_NRUE_CAP_INFO_IND);
@@ -6587,7 +6591,7 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             rrc_dcch_data_copy_t *dl_dcch_buffer = itti_malloc (TASK_RRC_NSA_UE,
                                                                 TASK_RRC_UE,
                                                                 sizeof(rrc_dcch_data_copy_t));
-            UE_RRC_INFO *info = &UE_rrc_inst[ctxt.module_id].Info[0];
+            UE_RRC_INFO *info = &UE_rrc_inst[ctxt_g.module_id].Info[0];
             dl_dcch_buffer->dl_dcch_msg = info->dl_dcch_msg;
             info->dl_dcch_msg = NULL;
             message_p = itti_alloc_new_message (TASK_RRC_UE, 0, RRC_DCCH_DATA_COPY_IND);
@@ -6650,13 +6654,13 @@ void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
             OCTET_STRING_fromBuf(&rrcConfigurationComplete,
                                 (const char *)msg_buffer,
                                 msg_len);
-            #if 0
+            #if 0 //Melissa, this is a hack. We need the transaction_id from latest dl_dcch_msg the LTE UE received. (Ln 6658)
             LTE_RRCConnectionReconfiguration_t *rrc_saved = &UE_rrc_inst[ctxt.module_id].Info[0].dl_dcch_msg->message.
                                                             choice.c1.choice.rrcConnectionReconfiguration;
             uint8_t t_id = rrc_saved->rrc_TransactionIdentifier;
             rrc_saved = NULL;
             #endif
-            rrc_ue_generate_RRCConnectionReconfigurationComplete(&ctxt, ctxt.eNB_index, 0, &rrcConfigurationComplete);
+            rrc_ue_generate_RRCConnectionReconfigurationComplete(&ctxt_g, ctxt_g.eNB_index, 0, &rrcConfigurationComplete);
             break;
         }
         default:

openair2/RRC/LTE/rrc_eNB_endc.c

@@ -173,7 +173,7 @@ int rrc_eNB_generate_RRCConnectionReconfiguration_endc(protocol_ctxt_t *ctxt,
   unsigned char scg_conf_buf[4] = { 0, 0, 0, 0 };
   if (scg_group_config!=NULL) {
 	  nr.choice.setup.nr_SecondaryCellGroupConfig_r15 = scg_group_config; //&scg_conf;
-          LOG_E(RRC, "Melissa Elkadi. setting scg_group_config\n");
+          LOG_E(RRC, "setting scg_group_config\n");
   }
   else{
 	  nr.choice.setup.nr_SecondaryCellGroupConfig_r15 = &dummy_scg_conf;
@@ -201,7 +201,7 @@ int rrc_eNB_generate_RRCConnectionReconfiguration_endc(protocol_ctxt_t *ctxt,
 
   if(scg_RB_config!=NULL) {
 	  cr_1510.nr_RadioBearerConfig1_r15 = scg_RB_config;
-          LOG_E(RRC, "Melissa Elkadi. setting scg_RB_config\n");
+          LOG_E(RRC, "setting scg_RB_config\n");
   }
   else{
 	  cr_1510.nr_RadioBearerConfig1_r15 = &dummy_nr1_conf;

openair2/RRC/NR/MESSAGES/asn1_msg.c

@@ -1411,7 +1411,7 @@ do_NR_RRCReconfigurationComplete_for_nsa(
                                                   buffer_size);
   AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
-  LOG_I(NR_RRC, "rrcReconfigurationComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8);
+  LOG_A(NR_RRC, "rrcReconfigurationComplete Encoded %zd bits (%zd bytes)\n", enc_rval.encoded, (enc_rval.encoded+7)/8);
   return((enc_rval.encoded+7)/8);
 }
 

openair2/RRC/NR/rrc_gNB.c

@@ -339,6 +339,8 @@ void rrc_gNB_process_AdditionRequestInformation(const module_id_t gnb_mod_idP, x
   AssertFatal(cg_configinfo->criticalExtensions.choice.c1->present == NR_CG_ConfigInfo__criticalExtensions__c1_PR_cg_ConfigInfo,
               "ueCapabilityInformation not present\n");
   parse_CG_ConfigInfo(rrc,cg_configinfo,m);
+  LOG_A(NR_RRC, "Successfully parced CG_ConfigInfo of size %zu bits. (%zu bytes)\n",
+        dec_rval.consumed, (dec_rval.consumed +7/8));
 }
 
 
@@ -2433,7 +2435,7 @@ void *rrc_gnb_task(void *args_p) {
         break;
 
       case X2AP_ENDC_SGNB_RECONF_COMPLETE:
-        LOG_I(NR_RRC, "Melissa Elkadi Handling of reconfiguration complete message at RRC gNB is pending \n");
+        LOG_A(NR_RRC, "Handling of reconfiguration complete message at RRC gNB is pending \n");
         break;
 
       case NGAP_INITIAL_CONTEXT_SETUP_REQ:

openair2/RRC/NR/rrc_gNB_internode.c

@@ -46,7 +46,6 @@ int parse_CG_ConfigInfo(gNB_RRC_INST *rrc, NR_CG_ConfigInfo_t *CG_ConfigInfo, x2
         NR_CG_ConfigInfo_IEs_t *cg_ConfigInfo = CG_ConfigInfo->criticalExtensions.choice.c1->choice.cg_ConfigInfo;
 
         if (cg_ConfigInfo->ue_CapabilityInfo) {
-          LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
           // Decode UE-CapabilityRAT-ContainerList
           NR_UE_CapabilityRAT_ContainerList_t *UE_CapabilityRAT_ContainerList=NULL;
           UE_CapabilityRAT_ContainerList = calloc(1,sizeof(NR_UE_CapabilityRAT_ContainerList_t));
@@ -60,7 +59,6 @@ int parse_CG_ConfigInfo(gNB_RRC_INST *rrc, NR_CG_ConfigInfo_t *CG_ConfigInfo, x2
             AssertFatal(1==0,"[InterNode] Failed to decode NR_UE_CapabilityRAT_ContainerList (%zu bits), size of OCTET_STRING %lu\n",
                         dec_rval.consumed, cg_ConfigInfo->ue_CapabilityInfo->size);
           }
-          LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
           rrc_parse_ue_capabilities(rrc,UE_CapabilityRAT_ContainerList, m,cg_ConfigInfo);
         }
 

openair2/RRC/NR/rrc_gNB_nsa.c

@@ -65,7 +65,6 @@ extern rlc_op_status_t nr_rrc_rlc_config_asn1_req (const protocol_ctxt_t   * con
     struct NR_CellGroupConfig__rlc_BearerToAddModList *rlc_bearer2add_list);
 
 void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc, NR_UE_CapabilityRAT_ContainerList_t *UE_CapabilityRAT_ContainerList, x2ap_ENDC_sgnb_addition_req_t *m, NR_CG_ConfigInfo_IEs_t  *cg_config_info) {
-  LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
   struct rrc_gNB_ue_context_s        *ue_context_p = NULL;
 
   OCTET_STRING_t *ueCapabilityRAT_Container_nr=NULL;
@@ -125,6 +124,7 @@ void rrc_parse_ue_capabilities(gNB_RRC_INST *rrc, NR_UE_CapabilityRAT_ContainerL
   if ( LOG_DEBUGFLAG(DEBUG_ASN1) && ueCapabilityRAT_Container_MRDC != NULL ) {
     xer_fprint(stdout, &asn_DEF_NR_UE_MRDC_Capability, ue_context_p->ue_context.UE_Capability_MRDC);
   }
+  LOG_A(RRC, "Successfully decoded UE NR capabilities (NR and MRDC)\n");
 
   rrc_add_nsa_user(rrc,ue_context_p, m);
 }
@@ -134,7 +134,6 @@ RB_PROTOTYPE(rrc_nr_ue_tree_s, rrc_gNB_ue_context_s, entries,
              rrc_gNB_compare_ue_rnti_id);
 
 void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_p, x2ap_ENDC_sgnb_addition_req_t *m) {
-  LOG_I(RRC, "Melissa Elkadi. We got here %s():%d\n", __FUNCTION__, __LINE__);
   // generate nr-Config-r15 containers for LTE RRC : inside message for X2 EN-DC (CG-Config Message from 38.331)
   rrc_gNB_carrier_data_t *carrier=&rrc->carrier;
   MessageDef *msg;
@@ -281,7 +280,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
       create_tunnel_req.num_tunnels    = m->nb_e_rabs_tobeadded;
       RB_INSERT(rrc_nr_ue_tree_s, &RC.nrrrc[rrc->module_id]->rrc_ue_head, ue_context_p);
       PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, rrc->module_id, GNB_FLAG_YES, ue_context_p->ue_id_rnti, 0, 0,rrc->module_id);
-      #if 0 //Melissa this is a hack.
+      #if 0 //Melissa this is a hack: we are bypassing the EPC functionality.
       gtpv1u_create_s1u_tunnel(
         ctxt.instance,
         &create_tunnel_req,
@@ -377,7 +376,7 @@ void rrc_add_nsa_user(gNB_RRC_INST *rrc,struct rrc_gNB_ue_context_s *ue_context_
       (LTE_PMCH_InfoList_r9_t *) NULL,
       ue_context_p->ue_context.secondaryCellGroup->rlc_BearerToAddModList);
 
-  LOG_I(RRC, "Melissa Elkadi. %s:%d: done RRC PDCP/RLC ASN1 request for UE rnti %x\n", __FUNCTION__, __LINE__, ctxt.rnti);
+  LOG_I(RRC, "%s:%d: done RRC PDCP/RLC ASN1 request for UE rnti %x\n", __FUNCTION__, __LINE__, ctxt.rnti);
 
 }
 

openair2/RRC/NR_UE/rrc_UE.c

@@ -289,7 +289,6 @@ int8_t nr_rrc_ue_process_rrcReconfiguration(const module_id_t module_id, NR_RRCR
           //  after first time, update it and free the memory after.
           NR_UE_rrc_inst[module_id].cell_group_config = cellGroupConfig;
           nr_rrc_ue_process_scg_config(module_id,cellGroupConfig);
-          LOG_I(NR_RRC, "Melissa, we have finished nr_rrc_ue_process_scg_config. Now freeing. \n");
           SEQUENCE_free(&asn_DEF_NR_CellGroupConfig, (void *)NR_UE_rrc_inst[module_id].cell_group_config, 0);
         }
       }
@@ -2994,7 +2993,7 @@ static void nsa_rrc_ue_process_ueCapabilityEnquiry(void)
   AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
                enc_rval.failed_type->name, enc_rval.encoded);
   UECap->sdu_size = (enc_rval.encoded + 7) / 8;
-  LOG_I(NR_RRC, "[NR_RRC] NRUE Capability encoded, %d bytes (%zd bits)\n",
+  LOG_A(NR_RRC, "[NR_RRC] NRUE Capability encoded, %d bytes (%zd bits)\n",
         UECap->sdu_size, enc_rval.encoded + 7);
   /* Melissa: Hack. Need to add ctxt->mod_id as array indices */
   NR_UE_rrc_inst[0].UECap = UECap;
@@ -3015,7 +3014,7 @@ static void nsa_rrc_ue_process_ueCapabilityEnquiry(void)
 
 void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
 {
-    LOG_I(NR_RRC, "We are processing an NSA message\n");
+    LOG_D(NR_RRC, "Processing an NSA message\n");
     Rrc_Msg_Type_t msg_type = msg->msg_type;
     uint8_t *const msg_buffer = msg->msg_buffer;
     msg_len -= sizeof(msg->msg_type);
@@ -3023,7 +3022,7 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
     {
         case UE_CAPABILITY_ENQUIRY:
         {
-            LOG_I(NR_RRC, "We are processing a %d message \n", msg_type);
+            LOG_D(NR_RRC, "We are processing a %d message \n", msg_type);
             NR_FreqBandList_t *nr_freq_band_list = NULL;
             asn_dec_rval_t dec_rval = uper_decode_complete(NULL,
                             &asn_DEF_NR_FreqBandList,
@@ -3042,9 +3041,9 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
                      nr_freq_band_list->list.array[i]->choice.bandInformationNR->bandNR);
             }
             MessageDef *dummy_msg = itti_alloc_new_message(TASK_RRC_NSA_UE, 0, UE_CAPABILITY_DUMMY);
-            LOG_I(NR_RRC, "We are calling nsa_sendmsg_to_lte_ue to send a UE_CAPABILITY_DUMMY\n");
+            LOG_D(NR_RRC, "We are calling nsa_sendmsg_to_lte_ue to send a UE_CAPABILITY_DUMMY\n");
             nsa_sendmsg_to_lte_ue(dummy_msg, sizeof(dummy_msg), UE_CAPABILITY_DUMMY);
-            LOG_I(NR_RRC, "We have sent a UE_CAPABILITY_DUMMY\n");
+            LOG_A(NR_RRC, "Sent initial NRUE Capability response to LTE UE\n");
             break;
         }
 
@@ -3084,17 +3083,10 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
               LOG_E(RRC, "Failed to decode measurement object (%zu bits) %d\n", dec_rval.consumed, dec_rval.code);
               break;
             }
-            LOG_I(NR_RRC, "NR carrierFreq_r15 (ssb): %ld and sub carrier spacing:%ld\n",
+            LOG_D(NR_RRC, "NR carrierFreq_r15 (ssb): %ld and sub carrier spacing:%ld\n",
                   nr_meas_obj->measObject.choice.measObjectNR_r15.carrierFreq_r15,
                   nr_meas_obj->measObject.choice.measObjectNR_r15.rs_ConfigSSB_r15.subcarrierSpacingSSB_r15);
             start_oai_nrue_threads();
-            /* Create a processs RRC_MEASUREMENT_PROCEDURE function. This
-               function will tell the NR UE which frequency to take measurements
-               on. You can log these values for fun. This will trigger 5G UE socket with proxy
-               to be opened. It will listen for PBCH from gNB (proxy technically). Then it will
-               call the ususal MIB functions to handle the MIB. Intervene in 5G stack to decode the MIB.
-               Also, after receiving PBCH it will start sending SSB index/cellID and some info from MIB to UE
-               as measurement reporting message*/
             break;
         }
         case RRC_CONFIG_COMPLETE_REQ:
@@ -3113,7 +3105,7 @@ void process_lte_nsa_msg(nsa_msg_t *msg, int msg_len)
             AssertFatal(sizeof(hdr) + nr_RadioBearer_size + nr_SecondaryCellGroup_size != msg_len,
                         "Bad received msg\n");
             NR_RRC_TransactionIdentifier_t t_id = hdr.trans_id;
-            LOG_I(NR_RRC, "nr_RadioBearerConfig1_r15 size %d nr_SecondaryCellGroupConfig_r15 size %d t_id %d\n",
+            LOG_I(NR_RRC, "nr_RadioBearerConfig1_r15 size %d nr_SecondaryCellGroupConfig_r15 size %d t_id %ld\n",
                       nr_RadioBearer_size,
                       nr_SecondaryCellGroup_size,
                       t_id);