From efeb48e09e4c55aae6af949ea9c7fbdc35012f56 Mon Sep 17 00:00:00 2001 From: Raymond Knopp Date: Sat, 25 Aug 2018 23:27:16 +0200 Subject: [PATCH] rrc_UE.c merged rrc_eNB.c doesn't compile --- openair2/RRC/LTE/rrc_UE.c | 426 ++++++++++++++++++------------------- openair2/RRC/LTE/rrc_eNB.c | 42 ++-- 2 files changed, 233 insertions(+), 235 deletions(-) diff --git a/openair2/RRC/LTE/rrc_UE.c b/openair2/RRC/LTE/rrc_UE.c index 13b710fb5d..0736a5902a 100644 --- a/openair2/RRC/LTE/rrc_UE.c +++ b/openair2/RRC/LTE/rrc_UE.c @@ -2922,13 +2922,13 @@ int decode_BCCH_DLSCH_Message( decode_SIB1( ctxt_pP, eNB_index, rsrq, rsrp ); } - + } break; - + case BCCH_DL_SCH_MessageType__c1_PR_systemInformation: if ((UE_rrc_inst[ctxt_pP->module_id].Info[eNB_index].SIStatus&1) == 1) { // SIB1 with schedulingInfoList is available - + SystemInformation_t* si = UE_rrc_inst[ctxt_pP->module_id].si[eNB_index]; memcpy( si, &bcch_message->message.choice.c1.choice.systemInformation, @@ -2941,24 +2941,24 @@ int decode_BCCH_DLSCH_Message( //if (nfapi_mode == 3) UE_mac_inst[ctxt_pP->module_id].SI_Decoded = 1; } - - break; - - case BCCH_DL_SCH_MessageType__c1_PR_NOTHING: - default: - break; + + break; + + case BCCH_DL_SCH_MessageType__c1_PR_NOTHING: + default: + break; } } - + if ((rrc_get_sub_state(ctxt_pP->module_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) #if defined(ENABLE_USE_MME) && (UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data != NULL) #endif - ) { + ) { rrc_ue_generate_RRCConnectionRequest(ctxt_pP, 0); rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_CONNECTING ); } - + VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_UE_DECODE_BCCH, VCD_FUNCTION_OUT ); return 0; } @@ -4536,20 +4536,22 @@ void *rrc_ue_task( void *args_p ) unsigned int ue_mod_id; int result; SRB_INFO *srb_info_p; + protocol_ctxt_t ctxt; itti_mark_task_ready (TASK_RRC_UE); while(1) { // Wait for a message itti_receive_msg (TASK_RRC_UE, &msg_p); + instance = ITTI_MSG_INSTANCE (msg_p); ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance); switch (ITTI_MSG_ID(msg_p)) { - case TERMINATE_MESSAGE: - LOG_W(RRC, " *** Exiting RRC thread\n"); - itti_exit_task (); - break; + case TERMINATE_MESSAGE: + LOG_W(RRC, " *** Exiting RRC thread\n"); + itti_exit_task (); + break; case MESSAGE_TEST: LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); @@ -4593,8 +4595,9 @@ void *rrc_ue_task( void *args_p ) LOG_D(RRC, "[UE %d] Received %s: eNB %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), RRC_MAC_CCCH_DATA_CNF (msg_p).enb_index); - - break; + // reset the tx buffer to indicate RRC that ccch was successfully transmitted (for example if contention resolution succeeds) + UE_rrc_inst[ue_mod_id].Srb0[RRC_MAC_CCCH_DATA_CNF (msg_p).enb_index].Tx_buffer.payload_size = 0; + break; case RRC_MAC_CCCH_DATA_IND: LOG_D(RRC, "[UE %d] RNTI %x Received %s: frameP %d, eNB %d\n", @@ -4669,8 +4672,9 @@ void *rrc_ue_task( void *args_p ) # if defined(ENABLE_USE_MME) - case NAS_KENB_REFRESH_REQ: - memcpy((void *)UE_rrc_inst[ue_mod_id].kenb, (void *)NAS_KENB_REFRESH_REQ(msg_p).kenb, sizeof(UE_rrc_inst[ue_mod_id].kenb)); + case NAS_KENB_REFRESH_REQ: + memcpy((void*)UE_rrc_inst[ue_mod_id].kenb, (void*)NAS_KENB_REFRESH_REQ(msg_p).kenb, sizeof(UE_rrc_inst[ue_mod_id].kenb)); + LOG_D(RRC, "[UE %d] Received %s: refreshed RRC::KeNB = " "%02x%02x%02x%02x" "%02x%02x%02x%02x" @@ -4728,82 +4732,60 @@ void *rrc_ue_task( void *args_p ) case RRC_STATE_INACTIVE: { /* Need to first activate lower layers */ MessageDef *message_p; - + message_p = itti_alloc_new_message(TASK_RRC_UE, ACTIVATE_MESSAGE); - + itti_send_msg_to_task(TASK_L2L1, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p); - - /* Save cell selection criterion */ - { - UE_rrc_inst[ue_mod_id].plmnID = NAS_CELL_SELECTION_REQ (msg_p).plmnID; - UE_rrc_inst[ue_mod_id].rat = NAS_CELL_SELECTION_REQ (msg_p).rat; - LOG_D(RRC, "[UE %d] Save cell selection criterion MCC %X%X%X MNC %X%X%X\n", - ue_mod_id, - UE_rrc_inst[ue_mod_id].plmnID.MCCdigit1, - UE_rrc_inst[ue_mod_id].plmnID.MCCdigit2, - UE_rrc_inst[ue_mod_id].plmnID.MCCdigit3, - UE_rrc_inst[ue_mod_id].plmnID.MNCdigit1, - UE_rrc_inst[ue_mod_id].plmnID.MNCdigit2, - UE_rrc_inst[ue_mod_id].plmnID.MNCdigit3); - } - - switch (rrc_get_state(ue_mod_id)) { - case RRC_STATE_INACTIVE: { - /* Need to first activate lower layers */ - MessageDef *message_p; - message_p = itti_alloc_new_message(TASK_RRC_UE, ACTIVATE_MESSAGE); - itti_send_msg_to_task(TASK_L2L1, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p); - rrc_set_state (ue_mod_id, RRC_STATE_IDLE); - /* Fall through to next case */ - } - - case RRC_STATE_IDLE: { - /* Ask to layer 1 to find a cell matching the criterion */ - MessageDef *message_p; - message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ); - PHY_FIND_CELL_REQ (message_p).earfcn_start = 1; - PHY_FIND_CELL_REQ (message_p).earfcn_end = 1; - itti_send_msg_to_task(TASK_PHY_UE, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p); - rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING); - break; - } - - case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); - break; - - default: - LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); - break; - } + + rrc_set_state (ue_mod_id, RRC_STATE_IDLE); + /* Fall through to next case */ + } + + case RRC_STATE_IDLE: { + /* Ask to layer 1 to find a cell matching the criterion */ + MessageDef *message_p; + + message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ); + + PHY_FIND_CELL_REQ (message_p).earfcn_start = 1; + PHY_FIND_CELL_REQ (message_p).earfcn_end = 1; + + itti_send_msg_to_task(TASK_PHY_UE, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p); + rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING); break; - - case RRC_STATE_INACTIVE: - case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id)); - break; - - case NAS_CONN_ESTABLI_REQ: - LOG_D(RRC, "[UE %d] Received %s: cause %d, type %d, s_tmsi (mme code %"PRIu8", m-tmsi %"PRIu32"), plmnID (%d%d%d.%d%d%d)\n", ue_mod_id, ITTI_MSG_NAME (msg_p), NAS_CONN_ESTABLI_REQ (msg_p).cause, - NAS_CONN_ESTABLI_REQ (msg_p).type, - NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.MMEcode, - NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.m_tmsi, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit1, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit2, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit3, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit1, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit2, - NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit3); - - //PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, NOT_A_RNTI, 0, 0); - PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, NOT_A_RNTI, 0, 0, 0); - - UE_rrc_inst[ue_mod_id].initialNasMsg = NAS_CONN_ESTABLI_REQ (msg_p).initialNasMsg; - - switch (rrc_get_state(ue_mod_id)) { + } + + case RRC_STATE_CONNECTED: + /* should not happen */ + LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); + break; + + default: + LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); + break; + } + + break; + + case NAS_CONN_ESTABLI_REQ: + LOG_D(RRC, "[UE %d] Received %s: cause %d, type %d, s_tmsi (mme code %"PRIu8", m-tmsi %"PRIu32"), plmnID (%d%d%d.%d%d%d)\n", ue_mod_id, ITTI_MSG_NAME (msg_p), NAS_CONN_ESTABLI_REQ (msg_p).cause, + NAS_CONN_ESTABLI_REQ (msg_p).type, + NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.MMEcode, + NAS_CONN_ESTABLI_REQ (msg_p).s_tmsi.m_tmsi, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit1, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit2, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MCCdigit3, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit1, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit2, + NAS_CONN_ESTABLI_REQ (msg_p).plmnID.MNCdigit3); + + //PROTOCOL_CTXT_SET_BY_INSTANCE(&ctxt, instance, ENB_FLAG_NO, NOT_A_RNTI, 0, 0); + PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, NOT_A_RNTI, 0, 0, 0); + + UE_rrc_inst[ue_mod_id].initialNasMsg = NAS_CONN_ESTABLI_REQ (msg_p).initialNasMsg; + + switch (rrc_get_state(ue_mod_id)) { case RRC_STATE_IDLE: { if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) { rrc_ue_generate_RRCConnectionRequest(&ctxt, 0); @@ -4813,6 +4795,7 @@ void *rrc_ue_task( void *args_p ) } break; + } case RRC_STATE_INACTIVE: case RRC_STATE_CONNECTED: @@ -4862,6 +4845,7 @@ void *rrc_ue_task( void *args_p ) } # endif + # if ENABLE_RAL case RRC_RAL_SCAN_REQ: @@ -4871,95 +4855,77 @@ void *rrc_ue_task( void *args_p ) case RRC_STATE_INACTIVE: { /* Need to first activate lower layers */ MessageDef *message_p; - + message_p = itti_alloc_new_message(TASK_RRC_UE, ACTIVATE_MESSAGE); - + itti_send_msg_to_task(TASK_L2L1, instance, message_p); - + rrc_set_state (ue_mod_id, RRC_STATE_IDLE); /* Fall through to next case */ } - + case RRC_STATE_IDLE: { if (rrc_get_sub_state(ue_mod_id) != RRC_SUB_STATE_IDLE_SEARCHING) { /* Ask to layer 1 to find a cell matching the criterion */ MessageDef *message_p; - - case RRC_STATE_IDLE: { - if (rrc_get_sub_state(ue_mod_id) != RRC_SUB_STATE_IDLE_SEARCHING) { - /* Ask to layer 1 to find a cell matching the criterion */ - MessageDef *message_p; - message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ); - rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING); - PHY_FIND_CELL_REQ (message_p).transaction_id = RRC_RAL_SCAN_REQ (msg_p).transaction_id; - PHY_FIND_CELL_REQ (message_p).earfcn_start = 1; - PHY_FIND_CELL_REQ (message_p).earfcn_end = 1; //44 - itti_send_msg_to_task(TASK_PHY_UE, instance, message_p); - } - - break; - } - - case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id)); - break; - - default: - LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); - break; + + message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ); + + rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING); + + PHY_FIND_CELL_REQ (message_p).transaction_id = RRC_RAL_SCAN_REQ (msg_p).transaction_id; + PHY_FIND_CELL_REQ (message_p).earfcn_start = 1; + PHY_FIND_CELL_REQ (message_p).earfcn_end = 1; //44 + + itti_send_msg_to_task(TASK_PHY_UE, instance, message_p); } - + + break; + } + + case RRC_STATE_CONNECTED: + /* should not happen */ + LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); break; - case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); - break; - - default: - LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); - break; + default: + LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); + break; } - - break; - - case PHY_FIND_CELL_IND: - LOG_D(RRC, "[UE %d] Received %s: state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); - - switch (rrc_get_state(ue_mod_id)) { - case RRC_STATE_IDLE: - switch (rrc_get_sub_state(ue_mod_id)) { - case RRC_SUB_STATE_IDLE_SEARCHING: - { - MessageDef *message_p; - int i; - - message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_SCAN_CONF); - - RRC_RAL_SCAN_CONF (message_p).transaction_id = PHY_FIND_CELL_IND(msg_p).transaction_id; - RRC_RAL_SCAN_CONF (message_p).num_scan_resp = PHY_FIND_CELL_IND(msg_p).cell_nb; - - rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE); - itti_send_msg_to_task(TASK_RAL_UE, instance, message_p); - break; - } - - default: - LOG_C(RRC, "[UE %d] Invalid RRC state %d substate %d\n", - ue_mod_id, - rrc_get_state(ue_mod_id), - rrc_get_sub_state(ue_mod_id)); - } - - break; - - case RRC_STATE_INACTIVE: - case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] indication %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id)); - break; - + + break; + + case PHY_FIND_CELL_IND: + LOG_D(RRC, "[UE %d] Received %s: state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); + + switch (rrc_get_state(ue_mod_id)) { + case RRC_STATE_IDLE: + switch (rrc_get_sub_state(ue_mod_id)) { + case RRC_SUB_STATE_IDLE_SEARCHING: { + MessageDef *message_p; + int i; + + message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_SCAN_CONF); + + RRC_RAL_SCAN_CONF (message_p).transaction_id = PHY_FIND_CELL_IND(msg_p).transaction_id; + RRC_RAL_SCAN_CONF (message_p).num_scan_resp = PHY_FIND_CELL_IND(msg_p).cell_nb; + + for (i = 0 ; i < PHY_FIND_CELL_IND(msg_p).cell_nb; i++) { + // TO DO + memset(&RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].link_addr, 0, sizeof(ral_link_addr_t)); + // TO DO + memset(&RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].network_id, 0, sizeof(ral_network_id_t)); + + RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength.choice = RAL_SIG_STRENGTH_CHOICE_DBM; + RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength._union.dbm = PHY_FIND_CELL_IND(msg_p).cells[i].rsrp; + } + + rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE); + + itti_send_msg_to_task(TASK_RAL_UE, instance, message_p); + break; + } + default: LOG_E(RRC, "[UE %d] Invalid RRC state %d substate %d\n", ue_mod_id, @@ -4968,57 +4934,90 @@ void *rrc_ue_task( void *args_p ) } break; - - case RRC_RAL_CONFIGURE_THRESHOLD_REQ: - rrc_ue_ral_handle_configure_threshold_request(ue_mod_id, msg_p); - break; - - case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ: - LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, msg_name); - - switch (rrc_get_state(ue_mod_id)) { - case RRC_STATE_IDLE: { - if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) { - PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, UE_rrc_inst[ue_mod_id].Info[0].rnti, 0, 0, 0); - rrc_ue_generate_RRCConnectionRequest(&ctxt, 0); - LOG_D(RRC, "not sending connection request\n"); - rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_CONNECTING); - } - - break; - } - - case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ: - LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); - - default: - LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); - break; - } - - break; - + case RRC_STATE_INACTIVE: case RRC_STATE_CONNECTED: - /* should not happen */ - LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); - break; -#endif - + /* should not happen */ + LOG_E(RRC, "[UE %d] indication %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); + break; + default: - LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); - break; + LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); + break; } - - result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p); - AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); - AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); - msg_p = NULL; - } + + break; // PHY_FIND_CELL_IND + + case PHY_MEAS_REPORT_IND: { + MessageDef *message_p; + message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_MEASUREMENT_REPORT_IND); + + memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold, + &PHY_MEAS_REPORT_IND(msg_p).threshold, + sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold)); + + memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param, + &PHY_MEAS_REPORT_IND(msg_p).link_param, + sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param)); + + LOG_D(RRC, "[UE %d] PHY_MEAS_REPORT_IN: sending msg %s to %s \n", ue_mod_id, "RRC_RAL_MEASUREMENT_REPORT_IND", "TASK_RAL_UE"); + itti_send_msg_to_task(TASK_RAL_UE, instance, message_p); + break; + } + + case RRC_RAL_CONFIGURE_THRESHOLD_REQ: + rrc_ue_ral_handle_configure_threshold_request(ue_mod_id, msg_p); + break; + + case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ: + LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); + + switch (rrc_get_state(ue_mod_id)) { + case RRC_STATE_IDLE: { + if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) { + PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, ue_mod_id, ENB_FLAG_NO, UE_rrc_inst[ue_mod_id].Info[0].rnti, 0, 0, 0); + rrc_ue_generate_RRCConnectionRequest(&ctxt, 0); + LOG_D(RRC, "not sending connection request\n"); + rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_CONNECTING); + } + + break; + } + + case RRC_STATE_INACTIVE: + case RRC_STATE_CONNECTED: + /* should not happen */ + LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); + break; + + default: + LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); + break; + } + + break; + + case RRC_RAL_CONNECTION_RELEASE_REQ: + LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); + break; +#endif + + default: + LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); + break; + } + + result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p); + AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); + AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); + msg_p = NULL; + } } #endif + + - + /*------------------------------------------------------------------------------*/ void @@ -5303,8 +5302,7 @@ rrc_ue_process_sidelink_radioResourceConfig( #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0)) //----------------------------------------------------------- -void -rrc_control_socket_init(){ +void rrc_control_socket_init(){ struct sockaddr_in rrc_ctrl_socket_addr; pthread_attr_t attr; diff --git a/openair2/RRC/LTE/rrc_eNB.c b/openair2/RRC/LTE/rrc_eNB.c index ccedd5883e..db92a69385 100644 --- a/openair2/RRC/LTE/rrc_eNB.c +++ b/openair2/RRC/LTE/rrc_eNB.c @@ -5478,28 +5478,28 @@ openair_rrc_eNB_init( RC.rrc[ctxt.module_id]->carrier[CC_id].paging[ue_id] = (uint8_t *) malloc16(256); } - } - rrc_init_global_param(); - + + rrc_init_global_param(); + #if (RRC_VERSION >= MAKE_VERSION(10, 0, 0)) switch (RC.rrc[ctxt.module_id]->carrier[CC_id].MBMS_flag) { - case 1: - case 2: - case 3: - LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 1 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); - RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 1; - break; - - case 4: - LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 2 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); - RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 2; - break; - - default: - RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 0; - break; + case 1: + case 2: + case 3: + LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 1 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); + RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 1; + break; + + case 4: + LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 2 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); + RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 2; + break; + + default: + RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 0; + break; } - + // if we are here the RC.rrc[enb_mod_idP]->MBMS_flag > 0, /// MCCH INIT if (RC.rrc[ctxt.module_id]->carrier[CC_id].MBMS_flag > 0) { @@ -5507,7 +5507,7 @@ openair_rrc_eNB_init( /// MTCH data bearer init init_MBMS(ctxt.module_id, CC_id, 0); } - + #endif openair_rrc_top_init_eNB(RC.rrc[ctxt.module_id]->carrier[CC_id].MBMS_flag,0); } @@ -5857,7 +5857,7 @@ rrc_eNB_decode_ccch( MSC_AS_TIME_ARGS(ctxt_pP), ue_context_p->ue_context.rnti, dec_rval.consumed); - } else { + } else { rrcConnectionRequest = &ul_ccch_msg->message.choice.c1.choice.rrcConnectionRequest.criticalExtensions.choice.rrcConnectionRequest_r8; { if (InitialUE_Identity_PR_randomValue == rrcConnectionRequest->ue_Identity.present) {