maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rrc_UE.c merged

Browse Source 
rrc_eNB.c doesn't compile
This commit is contained in:
Raymond Knopp
2018-08-25 23:27:16 +02:00
parent 019149e565
commit efeb48e09e
2 changed files with 233 additions and 235 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair2/RRC/LTE/rrc_UE.c
+165 -167
View File
@@ -2922,7 +2922,7 @@ int decode_BCCH_DLSCH_Message(
decode_SIB1( ctxt_pP, eNB_index, rsrq, rsrp ); decode_SIB1( ctxt_pP, eNB_index, rsrq, rsrp );
} }
}
break; break;
case BCCH_DL_SCH_MessageType__c1_PR_systemInformation: case BCCH_DL_SCH_MessageType__c1_PR_systemInformation:
@@ -2942,11 +2942,11 @@ int decode_BCCH_DLSCH_Message(
UE_mac_inst[ctxt_pP->module_id].SI_Decoded = 1; UE_mac_inst[ctxt_pP->module_id].SI_Decoded = 1;
} }
break; break;
case BCCH_DL_SCH_MessageType__c1_PR_NOTHING: case BCCH_DL_SCH_MessageType__c1_PR_NOTHING:
default: default:
break; break;
} }
} }
@@ -2954,7 +2954,7 @@ int decode_BCCH_DLSCH_Message(
#if defined(ENABLE_USE_MME) #if defined(ENABLE_USE_MME)
&& (UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data != NULL) && (UE_rrc_inst[ctxt_pP->module_id].initialNasMsg.data != NULL)
#endif #endif
) { ) {
rrc_ue_generate_RRCConnectionRequest(ctxt_pP, 0); rrc_ue_generate_RRCConnectionRequest(ctxt_pP, 0);
rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_CONNECTING ); rrc_set_sub_state( ctxt_pP->module_id, RRC_SUB_STATE_IDLE_CONNECTING );
} }
@@ -4536,20 +4536,22 @@ void *rrc_ue_task( void *args_p )
unsigned int ue_mod_id; unsigned int ue_mod_id;
int result; int result;
SRB_INFO *srb_info_p; SRB_INFO *srb_info_p;
protocol_ctxt_t ctxt; protocol_ctxt_t ctxt;
itti_mark_task_ready (TASK_RRC_UE); itti_mark_task_ready (TASK_RRC_UE);
while(1) { while(1) {
// Wait for a message // Wait for a message
itti_receive_msg (TASK_RRC_UE, &msg_p); itti_receive_msg (TASK_RRC_UE, &msg_p);
instance = ITTI_MSG_INSTANCE (msg_p); instance = ITTI_MSG_INSTANCE (msg_p);
ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance); ue_mod_id = UE_INSTANCE_TO_MODULE_ID(instance);
switch (ITTI_MSG_ID(msg_p)) { switch (ITTI_MSG_ID(msg_p)) {
case TERMINATE_MESSAGE: case TERMINATE_MESSAGE:
LOG_W(RRC, " *** Exiting RRC thread\n"); LOG_W(RRC, " *** Exiting RRC thread\n");
itti_exit_task (); itti_exit_task ();
break; break;
case MESSAGE_TEST: case MESSAGE_TEST:
LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); 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), 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); RRC_MAC_CCCH_DATA_CNF (msg_p).enb_index);
// reset the tx buffer to indicate RRC that ccch was successfully transmitted (for example if contention resolution succeeds)
break; 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: case RRC_MAC_CCCH_DATA_IND:
LOG_D(RRC, "[UE %d] RNTI %x Received %s: frameP %d, eNB %d\n", 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) # if defined(ENABLE_USE_MME)
case NAS_KENB_REFRESH_REQ: 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)); 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 = " LOG_D(RRC, "[UE %d] Received %s: refreshed RRC::KeNB = "
"%02x%02x%02x%02x" "%02x%02x%02x%02x"
"%02x%02x%02x%02x" "%02x%02x%02x%02x"
@@ -4733,77 +4737,55 @@ void *rrc_ue_task( void *args_p )
itti_send_msg_to_task(TASK_L2L1, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p); itti_send_msg_to_task(TASK_L2L1, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p);
/* Save cell selection criterion */ rrc_set_state (ue_mod_id, RRC_STATE_IDLE);
{ /* Fall through to next case */
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_IDLE: {
case RRC_STATE_INACTIVE: { /* Ask to layer 1 to find a cell matching the criterion */
/* Need to first activate lower layers */ MessageDef *message_p;
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: { message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ);
/* 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: PHY_FIND_CELL_REQ (message_p).earfcn_start = 1;
/* should not happen */ PHY_FIND_CELL_REQ (message_p).earfcn_end = 1;
LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
break;
default: itti_send_msg_to_task(TASK_PHY_UE, UE_MODULE_ID_TO_INSTANCE(ue_mod_id), message_p);
LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING);
break;
}
break; break;
}
case RRC_STATE_INACTIVE: case RRC_STATE_CONNECTED:
case RRC_STATE_CONNECTED: /* should not happen */
/* 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));
LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id)); break;
break;
case NAS_CONN_ESTABLI_REQ: default:
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, LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
NAS_CONN_ESTABLI_REQ (msg_p).type, break;
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); break;
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; 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);
switch (rrc_get_state(ue_mod_id)) { //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: { case RRC_STATE_IDLE: {
if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) { if (rrc_get_sub_state(ue_mod_id) == RRC_SUB_STATE_IDLE_SIB_COMPLETE) {
rrc_ue_generate_RRCConnectionRequest(&ctxt, 0); rrc_ue_generate_RRCConnectionRequest(&ctxt, 0);
@@ -4813,6 +4795,7 @@ void *rrc_ue_task( void *args_p )
} }
break; break;
}
case RRC_STATE_INACTIVE: case RRC_STATE_INACTIVE:
case RRC_STATE_CONNECTED: case RRC_STATE_CONNECTED:
@@ -4862,6 +4845,7 @@ void *rrc_ue_task( void *args_p )
} }
# endif # endif
# if ENABLE_RAL # if ENABLE_RAL
case RRC_RAL_SCAN_REQ: case RRC_RAL_SCAN_REQ:
@@ -4885,80 +4869,62 @@ void *rrc_ue_task( void *args_p )
/* Ask to layer 1 to find a cell matching the criterion */ /* Ask to layer 1 to find a cell matching the criterion */
MessageDef *message_p; MessageDef *message_p;
case RRC_STATE_IDLE: { message_p = itti_alloc_new_message(TASK_RRC_UE, PHY_FIND_CELL_REQ);
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; rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE_SEARCHING);
}
case RRC_STATE_CONNECTED: PHY_FIND_CELL_REQ (message_p).transaction_id = RRC_RAL_SCAN_REQ (msg_p).transaction_id;
/* should not happen */ PHY_FIND_CELL_REQ (message_p).earfcn_start = 1;
LOG_E(RRC, "[UE %d] request %s in RRC state %d\n", ue_mod_id, msg_name, rrc_get_state(ue_mod_id)); PHY_FIND_CELL_REQ (message_p).earfcn_end = 1; //44
break;
default: itti_send_msg_to_task(TASK_PHY_UE, instance, message_p);
LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
break;
} }
break; 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;
} }
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 PHY_FIND_CELL_IND: default:
LOG_D(RRC, "[UE %d] Received %s: state %d\n", ue_mod_id, ITTI_MSG_NAME (msg_p), rrc_get_state(ue_mod_id)); LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
break;
}
switch (rrc_get_state(ue_mod_id)) { break;
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); 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));
RRC_RAL_SCAN_CONF (message_p).transaction_id = PHY_FIND_CELL_IND(msg_p).transaction_id; switch (rrc_get_state(ue_mod_id)) {
RRC_RAL_SCAN_CONF (message_p).num_scan_resp = PHY_FIND_CELL_IND(msg_p).cell_nb; case RRC_STATE_IDLE:
switch (rrc_get_sub_state(ue_mod_id)) {
case RRC_SUB_STATE_IDLE_SEARCHING: {
MessageDef *message_p;
int i;
rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE); message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_SCAN_CONF);
itti_send_msg_to_task(TASK_RAL_UE, instance, message_p);
break;
}
default: RRC_RAL_SCAN_CONF (message_p).transaction_id = PHY_FIND_CELL_IND(msg_p).transaction_id;
LOG_C(RRC, "[UE %d] Invalid RRC state %d substate %d\n", RRC_RAL_SCAN_CONF (message_p).num_scan_resp = PHY_FIND_CELL_IND(msg_p).cell_nb;
ue_mod_id,
rrc_get_state(ue_mod_id),
rrc_get_sub_state(ue_mod_id));
}
break; 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));
case RRC_STATE_INACTIVE: RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength.choice = RAL_SIG_STRENGTH_CHOICE_DBM;
case RRC_STATE_CONNECTED: RRC_RAL_SCAN_CONF (message_p).link_scan_resp[i].sig_strength._union.dbm = PHY_FIND_CELL_IND(msg_p).cells[i].rsrp;
/* 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; rrc_set_sub_state (ue_mod_id, RRC_SUB_STATE_IDLE);
itti_send_msg_to_task(TASK_RAL_UE, instance, message_p);
break;
}
default: default:
LOG_E(RRC, "[UE %d] Invalid RRC state %d substate %d\n", LOG_E(RRC, "[UE %d] Invalid RRC state %d substate %d\n",
@@ -4969,57 +4935,90 @@ void *rrc_ue_task( void *args_p )
break; break;
case RRC_RAL_CONFIGURE_THRESHOLD_REQ: case RRC_STATE_INACTIVE:
rrc_ue_ral_handle_configure_threshold_request(ue_mod_id, msg_p); case RRC_STATE_CONNECTED:
break; /* 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;
case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ: default:
LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, msg_name); LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
break;
}
switch (rrc_get_state(ue_mod_id)) { break; // PHY_FIND_CELL_IND
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 PHY_MEAS_REPORT_IND: {
} MessageDef *message_p;
message_p = itti_alloc_new_message(TASK_RRC_UE, RRC_RAL_MEASUREMENT_REPORT_IND);
case RRC_RAL_CONNECTION_ESTABLISHMENT_REQ: memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold,
LOG_D(RRC, "[UE %d] Received %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); &PHY_MEAS_REPORT_IND(msg_p).threshold,
sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).threshold));
default: memcpy(&RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param,
LOG_C(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id)); &PHY_MEAS_REPORT_IND(msg_p).link_param,
break; sizeof(RRC_RAL_MEASUREMENT_REPORT_IND (message_p).link_param));
}
break; 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_INACTIVE:
case RRC_STATE_CONNECTED: case RRC_STATE_CONNECTED:
/* should not happen */ /* 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)); 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; break;
#endif
default: default:
LOG_E(RRC, "[UE %d] Received unexpected message %s\n", ue_mod_id, ITTI_MSG_NAME (msg_p)); LOG_E(RRC, "[UE %d] Invalid RRC state %d\n", ue_mod_id, rrc_get_state(ue_mod_id));
break; break;
} }
result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p); break;
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result); case RRC_RAL_CONNECTION_RELEASE_REQ:
msg_p = NULL; 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 #endif
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
void void
openair_rrc_top_init_ue( openair_rrc_top_init_ue(
@@ -5303,8 +5302,7 @@ rrc_ue_process_sidelink_radioResourceConfig(
#if (RRC_VERSION >= MAKE_VERSION(14, 0, 0)) #if (RRC_VERSION >= MAKE_VERSION(14, 0, 0))
//----------------------------------------------------------- //-----------------------------------------------------------
void void rrc_control_socket_init(){
rrc_control_socket_init(){
struct sockaddr_in rrc_ctrl_socket_addr; struct sockaddr_in rrc_ctrl_socket_addr;
pthread_attr_t attr; pthread_attr_t attr;
openair2/RRC/LTE/rrc_eNB.c
+16 -16
View File
@@ -5478,26 +5478,26 @@ openair_rrc_eNB_init(
RC.rrc[ctxt.module_id]->carrier[CC_id].paging[ue_id] = (uint8_t *) malloc16(256); 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)) #if (RRC_VERSION >= MAKE_VERSION(10, 0, 0))
switch (RC.rrc[ctxt.module_id]->carrier[CC_id].MBMS_flag) { switch (RC.rrc[ctxt.module_id]->carrier[CC_id].MBMS_flag) {
case 1: case 1:
case 2: case 2:
case 3: case 3:
LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 1 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); 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; RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 1;
break; break;
case 4: case 4:
LOG_I(RRC, PROTOCOL_RRC_CTXT_FMT" Configuring 2 MBSFN sync area\n", PROTOCOL_RRC_CTXT_ARGS(&ctxt)); 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; RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 2;
break; break;
default: default:
RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 0; RC.rrc[ctxt.module_id]->carrier[CC_id].num_mbsfn_sync_area = 0;
break; break;
} }
// if we are here the RC.rrc[enb_mod_idP]->MBMS_flag > 0, // if we are here the RC.rrc[enb_mod_idP]->MBMS_flag > 0,
@@ -5857,7 +5857,7 @@ rrc_eNB_decode_ccch(
MSC_AS_TIME_ARGS(ctxt_pP), MSC_AS_TIME_ARGS(ctxt_pP),
ue_context_p->ue_context.rnti, ue_context_p->ue_context.rnti,
dec_rval.consumed); dec_rval.consumed);
} else { } else {
rrcConnectionRequest = &ul_ccch_msg->message.choice.c1.choice.rrcConnectionRequest.criticalExtensions.choice.rrcConnectionRequest_r8; rrcConnectionRequest = &ul_ccch_msg->message.choice.c1.choice.rrcConnectionRequest.criticalExtensions.choice.rrcConnectionRequest_r8;
{ {
if (InitialUE_Identity_PR_randomValue == rrcConnectionRequest->ue_Identity.present) { if (InitialUE_Identity_PR_randomValue == rrcConnectionRequest->ue_Identity.present) {