Merge remote-tracking branch 'origin/remove_l2_sim' into integration_2025_w42 (!3686)
Remove NR L2 simulator code from UE This MR removes NR (SA and NSA) L2 simulator from the codebase. The code, at least at the UE side, was done at a time where there was no clear L2/L1 split leading to a complex implementation that never worked as expected. The L2 simulator has been broken and removed from testing for long time and, once it needs to be revived, it would require a complete new implementation.
This commit is contained in:
Jaroslava Fiedlerova
@@ -218,10 +218,6 @@ typedef struct kenb_refresh_req_s {
|
||||
uint8_t kenb[32];
|
||||
} kenb_refresh_req_t;
|
||||
|
||||
typedef struct nsa_oai_tun_nsa_s {
|
||||
uint8_t buffer[500];
|
||||
} nas_oai_tun_nsa_t;
|
||||
|
||||
/*
|
||||
* NAS->AS - Cell Information request
|
||||
* NAS request AS to search for a suitable cell belonging to the selected
|
||||
|
||||
@@ -31,7 +31,6 @@
|
||||
MESSAGE_DEF(RRC_DCCH_DATA_REQ, MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataReq, rrc_dcch_data_req)
|
||||
MESSAGE_DEF(RRC_DCCH_DATA_IND, MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataInd, rrc_dcch_data_ind)
|
||||
MESSAGE_DEF(RRC_PCCH_DATA_REQ, MESSAGE_PRIORITY_MED_PLUS, RrcPcchDataReq, rrc_pcch_data_req)
|
||||
MESSAGE_DEF(RRC_NRUE_CAP_INFO_IND, MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataInd, rrc_nrue_cap_info_ind)
|
||||
MESSAGE_DEF(RRC_DCCH_DATA_COPY_IND, MESSAGE_PRIORITY_MED_PLUS, RrcDcchDataInd, rrc_dcch_data_copy_ind)
|
||||
|
||||
// gNB
|
||||
|
||||
@@ -34,7 +34,6 @@
|
||||
#define RRC_DCCH_DATA_REQ(mSGpTR) (mSGpTR)->ittiMsg.rrc_dcch_data_req
|
||||
#define RRC_DCCH_DATA_IND(mSGpTR) (mSGpTR)->ittiMsg.rrc_dcch_data_ind
|
||||
#define RRC_PCCH_DATA_REQ(mSGpTR) (mSGpTR)->ittiMsg.rrc_pcch_data_req
|
||||
#define RRC_NRUE_CAP_INFO_IND(mSGpTR) (mSGpTR)->ittiMsg.rrc_nrue_cap_info_ind
|
||||
#define RRC_DCCH_DATA_COPY_IND(mSGpTR) (mSGpTR)->ittiMsg.rrc_dcch_data_copy_ind
|
||||
|
||||
// gNB
|
||||
|
||||
@@ -67,8 +67,6 @@ MESSAGE_DEF(NAS_5GMM_IND, MESSAGE_PRIORITY_MED, nas_5gmm_ind_t, nas_5gmm_ind)
|
||||
|
||||
MESSAGE_DEF(NAS_RAB_ESTABLI_RSP, MESSAGE_PRIORITY_MED, rab_establish_rsp_t, nas_rab_est_rsp)
|
||||
|
||||
MESSAGE_DEF(NAS_OAI_TUN_NSA, MESSAGE_PRIORITY_MED, nas_oai_tun_nsa_t, nas_oai_tun_nsa)
|
||||
|
||||
// UE: RRC -> NAS messages
|
||||
MESSAGE_DEF(NAS_CELL_SELECTION_CNF, MESSAGE_PRIORITY_MED, cell_info_cnf_t, nas_cell_selection_cnf)
|
||||
MESSAGE_DEF(NAS_CELL_SELECTION_IND, MESSAGE_PRIORITY_MED, cell_info_ind_t, nas_cell_selection_ind)
|
||||
|
||||
@@ -103,7 +103,6 @@
|
||||
#define RLC_SDU_INDICATION(mSGpTR) (mSGpTR)->ittiMsg.rlc_sdu_indication
|
||||
#define NRDuDlReq(mSGpTR) (mSGpTR)->ittiMsg.nr_du_dl_req
|
||||
|
||||
#define NAS_OAI_TUN_NSA(mSGpTR) (mSGpTR)->ittiMsg.nas_oai_tun_nsa
|
||||
#define NAS_PDU_SESSION_REQ(mSGpTR) (mSGpTR)->ittiMsg.nas_pdu_session_req
|
||||
|
||||
#define NR_RRC_RLC_MAXRTX(mSGpTR) (mSGpTR)->ittiMsg.nr_rlc_maxrtx_indication
|
||||
|
||||
@@ -320,35 +320,6 @@ typedef struct {
|
||||
uint8_t nbits;
|
||||
} dci_field_t;
|
||||
|
||||
typedef struct {
|
||||
/* The active harq sfn/slot field was created to save the
|
||||
scheduled SFN/Slot transmission for the ACK/NAK. If we
|
||||
do not save it, then we have to calculate it again as the
|
||||
NRUE MAC layer already does in get_downlink_ack(). */
|
||||
int active_dl_harq_sfn;
|
||||
int active_dl_harq_slot;
|
||||
int active_ul_harq_sfn;
|
||||
int active_ul_harq_slot;
|
||||
bool active;
|
||||
} emul_l1_harq_t;
|
||||
|
||||
typedef struct {
|
||||
bool expected_sib;
|
||||
bool index_has_sib[NR_MAX_HARQ_PROCESSES];
|
||||
bool expected_rar;
|
||||
bool index_has_rar[NR_MAX_HARQ_PROCESSES];
|
||||
bool expected_dci;
|
||||
bool index_has_dci[NR_MAX_HARQ_PROCESSES];
|
||||
emul_l1_harq_t harq[NR_MAX_HARQ_PROCESSES];
|
||||
int active_uci_sfn_slot;
|
||||
int num_srs;
|
||||
int num_harqs;
|
||||
int num_csi_reports;
|
||||
uint8_t pmi;
|
||||
uint8_t ri;
|
||||
uint8_t cqi;
|
||||
} nr_emulated_l1_t;
|
||||
|
||||
typedef struct {
|
||||
|
||||
uint8_t format_indicator; //1 bit
|
||||
|
||||
@@ -1942,8 +1942,7 @@ void nr_rrc_mac_config_req_sib1(module_id_t module_id, int cc_idP, NR_SIB1_t *si
|
||||
if (mac->state == UE_RECEIVING_SIB && can_start_ra)
|
||||
mac->state = UE_PERFORMING_RA;
|
||||
|
||||
if (!get_softmodem_params()->emulate_l1)
|
||||
mac->if_module->phy_config_request(&mac->phy_config);
|
||||
mac->if_module->phy_config_request(&mac->phy_config);
|
||||
ret = pthread_mutex_unlock(&mac->if_mutex);
|
||||
AssertFatal(!ret, "mutex failed %d\n", ret);
|
||||
}
|
||||
@@ -2002,13 +2001,11 @@ static void handle_reconfiguration_with_sync(NR_UE_MAC_INST_t *mac,
|
||||
ra->ra_state = nrRA_UE_IDLE;
|
||||
nr_ue_mac_default_configs(mac);
|
||||
|
||||
if (!get_softmodem_params()->emulate_l1) {
|
||||
mac->synch_request.Mod_id = mac->ue_id;
|
||||
mac->synch_request.CC_id = cc_idP;
|
||||
mac->synch_request.synch_req.target_Nid_cell = mac->physCellId;
|
||||
mac->if_module->synch_request(&mac->synch_request);
|
||||
mac->if_module->phy_config_request(&mac->phy_config);
|
||||
}
|
||||
mac->synch_request.Mod_id = mac->ue_id;
|
||||
mac->synch_request.CC_id = cc_idP;
|
||||
mac->synch_request.synch_req.target_Nid_cell = mac->physCellId;
|
||||
mac->if_module->synch_request(&mac->synch_request);
|
||||
mac->if_module->phy_config_request(&mac->phy_config);
|
||||
}
|
||||
|
||||
static void configure_physicalcellgroup(NR_UE_MAC_INST_t *mac,
|
||||
|
||||
@@ -646,8 +646,6 @@ typedef struct NR_UE_MAC_INST_s {
|
||||
NR_TimeAlignmentTimer_t timeAlignmentTimerCommon;
|
||||
NR_timer_t time_alignment_timer;
|
||||
|
||||
nr_emulated_l1_t nr_ue_emul_l1;
|
||||
|
||||
pthread_mutex_t mutex_dl_info;
|
||||
|
||||
//SIDELINK MAC PARAMETERS
|
||||
|
||||
@@ -835,34 +835,7 @@ bool init_RA(NR_UE_MAC_INST_t *mac, int frame)
|
||||
|
||||
// TODO this piece of code is required to compute MSG3_size that is used by ra_preambles_config function
|
||||
// Not a good implementation, it needs improvements
|
||||
int size_sdu = 0;
|
||||
|
||||
// Concerning the C-RNTI MAC CE,
|
||||
// it has to be included if the UL transmission (Msg3) is not being made for the CCCH logical channel.
|
||||
// Therefore it has been assumed that this event only occurs only when RA is done and it is not SA mode.
|
||||
if (get_softmodem_params()->nsa) {
|
||||
|
||||
uint8_t mac_sdus[34 * 1056];
|
||||
uint16_t sdu_lengths[NB_RB_MAX] = {0};
|
||||
int TBS_bytes = 848;
|
||||
int mac_ce_len = 0;
|
||||
unsigned short post_padding = 1;
|
||||
|
||||
// fill ulsch_buffer with random data
|
||||
for (int i = 0; i < TBS_bytes; i++) {
|
||||
mac_sdus[i] = (unsigned char)(rand()&0xff);
|
||||
}
|
||||
// Sending SDUs with size 1
|
||||
// Initialize elements of sdu_lengths
|
||||
sdu_lengths[0] = TBS_bytes - 3 - post_padding - mac_ce_len;
|
||||
size_sdu += sdu_lengths[0];
|
||||
|
||||
if (size_sdu > 0) {
|
||||
memcpy(ra->cont_res_id, mac_sdus, sizeof(uint8_t) * 6);
|
||||
ra->Msg3_size = size_sdu + sizeof(NR_MAC_SUBHEADER_SHORT) + sizeof(NR_MAC_SUBHEADER_SHORT);
|
||||
}
|
||||
|
||||
} else if (!IS_SA_MODE(get_softmodem_params()))
|
||||
if (!IS_SA_MODE(get_softmodem_params()))
|
||||
ra->Msg3_size = sizeof(uint16_t) + sizeof(NR_MAC_SUBHEADER_FIXED);
|
||||
|
||||
// Random acces procedure initialization
|
||||
@@ -1253,7 +1226,6 @@ void prepare_msg4_msgb_feedback(NR_UE_MAC_INST_t *mac, int pid, int ack_nack)
|
||||
NR_UE_DL_HARQ_STATUS_t *current_harq = &mac->dl_harq_info[pid];
|
||||
int sched_slot = current_harq->ul_slot;
|
||||
int sched_frame = current_harq->ul_frame;
|
||||
mac->nr_ue_emul_l1.num_harqs = 1;
|
||||
PUCCH_sched_t pucch = {.n_CCE = current_harq->n_CCE,
|
||||
.N_CCE = current_harq->N_CCE,
|
||||
.ack_payload = ack_nack,
|
||||
|
||||
@@ -2416,11 +2416,6 @@ bool get_downlink_ack(NR_UE_MAC_INST_t *mac, frame_t frame, int slot, PUCCH_sche
|
||||
dl_harq_pid, current_harq->ul_frame, current_harq->ul_slot);
|
||||
/* check if current tx slot should transmit downlink acknowlegment */
|
||||
if (current_harq->ul_frame == frame && current_harq->ul_slot == slot) {
|
||||
if (get_softmodem_params()->emulate_l1) {
|
||||
mac->nr_ue_emul_l1.harq[dl_harq_pid].active = true;
|
||||
mac->nr_ue_emul_l1.harq[dl_harq_pid].active_dl_harq_sfn = frame;
|
||||
mac->nr_ue_emul_l1.harq[dl_harq_pid].active_dl_harq_slot = slot;
|
||||
}
|
||||
if (res_ind != -1 && res_ind != current_harq->pucch_resource_indicator)
|
||||
LOG_E(NR_MAC,
|
||||
"Value of pucch_resource_indicator %d not matching with what set before %d (Possibly due to a false DCI) \n",
|
||||
@@ -3045,18 +3040,6 @@ static csi_payload_t get_csirs_RI_PMI_CQI_payload(NR_UE_MAC_INST_t *mac,
|
||||
int pmi_x1_bitlen = csi_report->csi_meas_bitlen.pmi_x1_bitlen[mac->l1_measurements.rank_indicator];
|
||||
int pmi_x2_bitlen = csi_report->csi_meas_bitlen.pmi_x2_bitlen[mac->l1_measurements.rank_indicator];
|
||||
int cqi_bitlen = csi_report->csi_meas_bitlen.cqi_bitlen[mac->l1_measurements.rank_indicator];
|
||||
|
||||
if (get_softmodem_params()->emulate_l1) {
|
||||
static const uint8_t mcs_to_cqi[] = {0, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9,
|
||||
10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15};
|
||||
CHECK_INDEX(nr_bler_data, NR_NUM_MCS - 1);
|
||||
int mcs = get_mcs_from_sinr(nr_bler_data, (mac->nr_ue_emul_l1.cqi - 640) * 0.1);
|
||||
CHECK_INDEX(mcs_to_cqi, mcs);
|
||||
mac->l1_measurements.rank_indicator = mac->nr_ue_emul_l1.ri;
|
||||
mac->l1_measurements.i1 = mac->nr_ue_emul_l1.pmi;
|
||||
mac->l1_measurements.cqi = mcs_to_cqi[mcs];
|
||||
}
|
||||
|
||||
int padding_bitlen = 0;
|
||||
// TODO: Improvements will be needed to cri_bitlen>0 and pmi_x1_bitlen>0
|
||||
if (mapping_type == ON_PUSCH) {
|
||||
@@ -4284,21 +4267,6 @@ static void nr_ue_process_rar(NR_UE_MAC_INST_t *mac, nr_downlink_indication_t *d
|
||||
handle_rar_reception(mac, rar, frame, slot);
|
||||
if (ra->cfra)
|
||||
nr_ra_succeeded(mac, dl_info->gNB_index, frame, slot);
|
||||
if (get_softmodem_params()->emulate_l1) {
|
||||
/* When we are emulating L1 with multiple UEs, the rx_indication will have
|
||||
multiple RAR PDUs. The code would previously handle each of these PDUs,
|
||||
but it should only be handling the single RAR that matches the current
|
||||
UE. */
|
||||
LOG_I(NR_MAC, "RAR PDU found for our UE with PDU index %d\n", pdu_id);
|
||||
dl_info->rx_ind->number_pdus = 1;
|
||||
if (pdu_id != 0) {
|
||||
memcpy(&dl_info->rx_ind->rx_indication_body[0],
|
||||
&dl_info->rx_ind->rx_indication_body[pdu_id],
|
||||
sizeof(fapi_nr_rx_indication_body_t));
|
||||
}
|
||||
mac->nr_ue_emul_l1.expected_rar = false;
|
||||
memset(mac->nr_ue_emul_l1.index_has_rar, 0, sizeof(mac->nr_ue_emul_l1.index_has_rar));
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (rarh->E == 0) {
|
||||
|
||||
@@ -1718,10 +1718,6 @@ static bool schedule_uci_on_pusch(NR_UE_MAC_INST_t *mac,
|
||||
static void nr_ue_pucch_scheduler(NR_UE_MAC_INST_t *mac, frame_t frame, int slot)
|
||||
{
|
||||
PUCCH_sched_t pucch[3] = {0}; // TODO the size might change in the future in case of multiple SR or multiple CSI in a slot
|
||||
|
||||
mac->nr_ue_emul_l1.num_srs = 0;
|
||||
mac->nr_ue_emul_l1.num_harqs = 0;
|
||||
mac->nr_ue_emul_l1.num_csi_reports = 0;
|
||||
int num_res = 0;
|
||||
|
||||
if (mac->ra.ra_pucch) {
|
||||
@@ -1771,9 +1767,6 @@ static void nr_ue_pucch_scheduler(NR_UE_MAC_INST_t *mac, frame_t frame, int slot
|
||||
pucch[j].n_harq,
|
||||
pucch[j].n_sr,
|
||||
pucch[j].n_csi);
|
||||
mac->nr_ue_emul_l1.num_srs = pucch[j].n_sr;
|
||||
mac->nr_ue_emul_l1.num_harqs = pucch[j].n_harq;
|
||||
mac->nr_ue_emul_l1.num_csi_reports = pucch[j].n_csi;
|
||||
|
||||
// checking if we need to schedule pucch[j] on PUSCH
|
||||
if (schedule_uci_on_pusch(mac, frame, slot, &pucch[j], mac->current_UL_BWP))
|
||||
@@ -1784,9 +1777,6 @@ static void nr_ue_pucch_scheduler(NR_UE_MAC_INST_t *mac, frame_t frame, int slot
|
||||
LOG_E(NR_MAC, "Error in pucch allocation\n");
|
||||
return;
|
||||
}
|
||||
DevAssert(mac->current_DL_BWP != NULL);
|
||||
int mu = mac->current_DL_BWP->scs;
|
||||
mac->nr_ue_emul_l1.active_uci_sfn_slot = NFAPI_SFNSLOT2DEC(mu, frame, slot);
|
||||
int ret = nr_ue_configure_pucch(mac,
|
||||
slot,
|
||||
frame,
|
||||
|
||||
@@ -1261,7 +1261,7 @@ pdcp_run (
|
||||
|
||||
// IP/NAS -> PDCP traffic : TX, read the pkt from the upper layer buffer
|
||||
// if (LINK_ENB_PDCP_TO_GTPV1U && ctxt_pP->enb_flag == ENB_FLAG_NO) {
|
||||
if (!get_softmodem_params()->emulate_l1 && (IS_SOFTMODEM_NOS1 || ctxt_pP->enb_flag == ENB_FLAG_NO)) {
|
||||
if (IS_SOFTMODEM_NOS1 || ctxt_pP->enb_flag == ENB_FLAG_NO) {
|
||||
pdcp_fifo_read_input_sdus(ctxt_pP);
|
||||
}
|
||||
|
||||
@@ -1271,9 +1271,7 @@ pdcp_run (
|
||||
} else {
|
||||
start_meas(&UE_pdcp_stats[ctxt_pP->module_id].pdcp_ip);
|
||||
}
|
||||
if (!get_softmodem_params()->emulate_l1) {
|
||||
pdcp_fifo_flush_sdus(ctxt_pP);
|
||||
}
|
||||
pdcp_fifo_flush_sdus(ctxt_pP);
|
||||
|
||||
if (ctxt_pP->enb_flag) {
|
||||
stop_meas(&eNB_pdcp_stats[ctxt_pP->module_id].pdcp_ip);
|
||||
|
||||
@@ -138,8 +138,6 @@ void NR_IF_Module_kill(int Mod_id);
|
||||
|
||||
void NR_UL_indication(NR_UL_IND_t *UL_INFO);
|
||||
|
||||
void RCconfig_nr_ue_macrlc(void);
|
||||
|
||||
/*Interface for Downlink, transmitting the DLSCH SDU, DCI SDU*/
|
||||
void NR_Schedule_Response(NR_Sched_Rsp_t *Sched_INFO);
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -34,11 +34,8 @@
|
||||
#define __NR_IF_MODULE_H__
|
||||
|
||||
#include "common/platform_types.h"
|
||||
#include <semaphore.h>
|
||||
#include "fapi_nr_ue_interface.h"
|
||||
#include "openair2/PHY_INTERFACE/queue_t.h"
|
||||
#include "openair2/NR_PHY_INTERFACE/NR_IF_Module.h"
|
||||
#include "NR_Packet_Drop.h"
|
||||
#include "nfapi/open-nFAPI/nfapi/public_inc/sidelink_nr_ue_interface.h"
|
||||
|
||||
typedef enum sl_sidelink_slot_type {
|
||||
@@ -50,19 +47,6 @@ typedef enum sl_sidelink_slot_type {
|
||||
|
||||
} sl_sidelink_slot_type_t;
|
||||
|
||||
extern queue_t nr_rach_ind_queue;
|
||||
extern queue_t nr_rx_ind_queue;
|
||||
extern queue_t nr_crc_ind_queue;
|
||||
extern queue_t nr_uci_ind_queue;
|
||||
extern queue_t nr_sfn_slot_queue;
|
||||
extern queue_t nr_chan_param_queue;
|
||||
extern queue_t nr_dl_tti_req_queue;
|
||||
extern queue_t nr_tx_req_queue;
|
||||
extern queue_t nr_ul_dci_req_queue;
|
||||
extern queue_t nr_ul_tti_req_queue;
|
||||
|
||||
extern slot_rnti_mcs_s slot_rnti_mcs[NUM_NFAPI_SLOT];
|
||||
|
||||
typedef struct NR_UL_TIME_ALIGNMENT NR_UL_TIME_ALIGNMENT_t;
|
||||
|
||||
typedef struct {
|
||||
@@ -292,32 +276,6 @@ typedef struct nr_ue_if_module_s {
|
||||
\param module_id module id*/
|
||||
nr_ue_if_module_t *nr_ue_if_module_init(uint32_t module_id);
|
||||
|
||||
void nrue_init_standalone_socket(int tx_port, int rx_port);
|
||||
|
||||
void *nrue_standalone_pnf_task(void *context);
|
||||
extern sem_t sfn_slot_semaphore;
|
||||
|
||||
typedef struct nfapi_dl_tti_config_req_tx_data_req_t
|
||||
{
|
||||
nfapi_nr_dl_tti_request_pdu_t *dl_itti_config_req;
|
||||
nfapi_nr_tx_data_request_t *tx_data_req_pdu_list;
|
||||
} nfapi_dl_tti_config_req_tx_data_req_t;
|
||||
|
||||
void send_nsa_standalone_msg(NR_UL_IND_t *UL_INFO, uint16_t msg_id);
|
||||
|
||||
void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request);
|
||||
|
||||
void check_and_process_dci(nfapi_nr_dl_tti_request_t *dl_tti_request,
|
||||
nfapi_nr_tx_data_request_t *tx_data_request,
|
||||
nfapi_nr_ul_dci_request_t *ul_dci_request,
|
||||
nfapi_nr_ul_tti_request_t *ul_tti_request);
|
||||
|
||||
struct sfn_slot_s {
|
||||
int sfn;
|
||||
int slot;
|
||||
};
|
||||
bool sfn_slot_matcher(void *sfn_slot_s, void *candidate);
|
||||
|
||||
/**\brief interface between L1/L2, indicating the downlink related information, like dci_ind and rx_req
|
||||
\param dl_info including dci_ind and rx_request messages*/
|
||||
int nr_ue_dl_indication(nr_downlink_indication_t *dl_info);
|
||||
|
||||
@@ -4521,117 +4521,8 @@ is_en_dc_supported(
|
||||
#undef NCE
|
||||
}
|
||||
|
||||
void allocate_en_DC_r15(LTE_UE_EUTRA_Capability_t *cap)
|
||||
OAI_UECapability_t *fill_ue_capability(char *UE_EUTRA_Capability_xer_fname)
|
||||
{
|
||||
LOG_D(RRC, "Entered %s\n", __FUNCTION__);
|
||||
if (!cap->nonCriticalExtension)
|
||||
cap->nonCriticalExtension = CALLOC(1, sizeof(*cap->nonCriticalExtension));
|
||||
|
||||
typeof(cap->nonCriticalExtension) nce1 = cap->nonCriticalExtension;
|
||||
if (!nce1->nonCriticalExtension)
|
||||
nce1->nonCriticalExtension = CALLOC(1, sizeof(*nce1->nonCriticalExtension));
|
||||
|
||||
typeof(nce1->nonCriticalExtension) nce2 = nce1->nonCriticalExtension;
|
||||
if (!nce2->nonCriticalExtension)
|
||||
nce2->nonCriticalExtension = CALLOC(1, sizeof(*nce2->nonCriticalExtension));
|
||||
|
||||
typeof(nce2->nonCriticalExtension) nce3 = nce2->nonCriticalExtension;
|
||||
if (!nce3->nonCriticalExtension)
|
||||
nce3->nonCriticalExtension = CALLOC(1, sizeof(*nce3->nonCriticalExtension));
|
||||
|
||||
typeof(nce3->nonCriticalExtension) nce4 = nce3->nonCriticalExtension;
|
||||
if (!nce4->nonCriticalExtension)
|
||||
nce4->nonCriticalExtension = CALLOC(1, sizeof(*nce4->nonCriticalExtension));
|
||||
|
||||
typeof(nce4->nonCriticalExtension) nce5 = nce4->nonCriticalExtension;
|
||||
if (!nce5->nonCriticalExtension)
|
||||
nce5->nonCriticalExtension = CALLOC(1, sizeof(*nce5->nonCriticalExtension));
|
||||
|
||||
typeof(nce5->nonCriticalExtension) nce6 = nce5->nonCriticalExtension;
|
||||
if (!nce6->nonCriticalExtension)
|
||||
nce6->nonCriticalExtension = CALLOC(1, sizeof(*nce6->nonCriticalExtension));
|
||||
|
||||
typeof(nce6->nonCriticalExtension) nce7 = nce6->nonCriticalExtension;
|
||||
if (!nce7->nonCriticalExtension)
|
||||
nce7->nonCriticalExtension = CALLOC(1, sizeof(*nce7->nonCriticalExtension));
|
||||
|
||||
typeof(nce7->nonCriticalExtension) nce8 = nce7->nonCriticalExtension;
|
||||
if (!nce8->nonCriticalExtension)
|
||||
nce8->nonCriticalExtension = CALLOC(1, sizeof(*nce8->nonCriticalExtension));
|
||||
|
||||
typeof(nce8->nonCriticalExtension) nce9 = nce8->nonCriticalExtension;
|
||||
if (!nce9->nonCriticalExtension)
|
||||
nce9->nonCriticalExtension = CALLOC(1, sizeof(*nce9->nonCriticalExtension));
|
||||
|
||||
typeof(nce9->nonCriticalExtension) nce10 = nce9->nonCriticalExtension;
|
||||
if (!nce10->nonCriticalExtension)
|
||||
nce10->nonCriticalExtension = CALLOC(1, sizeof(*nce10->nonCriticalExtension));
|
||||
|
||||
typeof(nce10->nonCriticalExtension) nce11 = nce10->nonCriticalExtension;
|
||||
if (!nce11->nonCriticalExtension)
|
||||
nce11->nonCriticalExtension = CALLOC(1, sizeof(*nce11->nonCriticalExtension));
|
||||
|
||||
typeof(nce11->nonCriticalExtension) nce12 = nce11->nonCriticalExtension;
|
||||
if (!nce12->nonCriticalExtension)
|
||||
nce12->nonCriticalExtension = CALLOC(1, sizeof(*nce12->nonCriticalExtension));
|
||||
|
||||
typeof(nce12->nonCriticalExtension) nce13 = nce12->nonCriticalExtension;
|
||||
if (!nce13->nonCriticalExtension)
|
||||
nce13->nonCriticalExtension = CALLOC(1, sizeof(*nce13->nonCriticalExtension));
|
||||
|
||||
typeof(nce13->nonCriticalExtension) nce14 = nce13->nonCriticalExtension;
|
||||
if (!nce14->nonCriticalExtension)
|
||||
nce14->nonCriticalExtension = CALLOC(1, sizeof(*nce14->nonCriticalExtension));
|
||||
|
||||
typeof(nce14->nonCriticalExtension) nce15 = nce14->nonCriticalExtension;
|
||||
if (!nce15->nonCriticalExtension)
|
||||
nce15->nonCriticalExtension = CALLOC(1, sizeof(*nce15->nonCriticalExtension));
|
||||
|
||||
typeof(nce15->nonCriticalExtension) nce16 = nce15->nonCriticalExtension;
|
||||
if (!nce16->nonCriticalExtension)
|
||||
nce16->nonCriticalExtension = CALLOC(1, sizeof(*nce16->nonCriticalExtension));
|
||||
|
||||
typeof(nce16->nonCriticalExtension) nce17 = nce16->nonCriticalExtension;
|
||||
if (!nce17->nonCriticalExtension)
|
||||
nce17->nonCriticalExtension = CALLOC(1, sizeof(*nce17->nonCriticalExtension));
|
||||
|
||||
typeof(nce17->nonCriticalExtension) nce18 = nce17->nonCriticalExtension;
|
||||
if (!nce18->nonCriticalExtension)
|
||||
nce18->nonCriticalExtension = CALLOC(1, sizeof(*nce18->nonCriticalExtension));
|
||||
|
||||
typeof(nce18->nonCriticalExtension) nce19 = nce18->nonCriticalExtension;
|
||||
if (!nce19->nonCriticalExtension)
|
||||
nce19->nonCriticalExtension = CALLOC(1, sizeof(*nce19->nonCriticalExtension));
|
||||
|
||||
typeof(nce19->nonCriticalExtension) nce20 = nce19->nonCriticalExtension;
|
||||
if (!nce20->nonCriticalExtension)
|
||||
nce20->nonCriticalExtension = CALLOC(1, sizeof(*nce20->nonCriticalExtension));
|
||||
|
||||
typeof(nce20->nonCriticalExtension) nce21 = nce20->nonCriticalExtension;
|
||||
if (!nce21->nonCriticalExtension)
|
||||
nce21->nonCriticalExtension = CALLOC(1, sizeof(*nce21->nonCriticalExtension));
|
||||
|
||||
typeof(nce21->nonCriticalExtension) nce22 = nce21->nonCriticalExtension;
|
||||
if (!nce22->nonCriticalExtension)
|
||||
nce22->nonCriticalExtension = CALLOC(1, sizeof(*nce22->nonCriticalExtension));
|
||||
|
||||
typeof(nce22->nonCriticalExtension) nce23 = nce22->nonCriticalExtension;
|
||||
if (!nce23->nonCriticalExtension)
|
||||
nce23->nonCriticalExtension = CALLOC(1, sizeof(*nce23->nonCriticalExtension));
|
||||
|
||||
typeof(nce23->nonCriticalExtension) nce24 = nce23->nonCriticalExtension;
|
||||
if (!nce24->irat_ParametersNR_r15)
|
||||
nce24->irat_ParametersNR_r15 = CALLOC(1, sizeof(*nce24->irat_ParametersNR_r15));
|
||||
|
||||
typeof(nce24->irat_ParametersNR_r15) irat = nce24->irat_ParametersNR_r15;
|
||||
if (!irat->en_DC_r15)
|
||||
irat->en_DC_r15 = CALLOC(1, sizeof(*irat->en_DC_r15));
|
||||
|
||||
*irat->en_DC_r15 = LTE_IRAT_ParametersNR_r15__en_DC_r15_supported;
|
||||
|
||||
}
|
||||
|
||||
OAI_UECapability_t *fill_ue_capability(char *UE_EUTRA_Capability_xer_fname, bool received_nr_msg) {
|
||||
static OAI_UECapability_t UECapability; /* TODO declared static to allow returning this has an address should be allocated in a cleaner way. */
|
||||
static LTE_SupportedBandEUTRA_t Bandlist[4]; // the macro asn1cSeqAdd() does not copy the source, but only stores a reference to it
|
||||
static LTE_InterFreqBandInfo_t InterFreqBandInfo[4][4]; // the macro asn1cSeqAdd() does not copy the source, but only stores a reference to it
|
||||
@@ -4716,14 +4607,6 @@ OAI_UECapability_t *fill_ue_capability(char *UE_EUTRA_Capability_xer_fname, bool
|
||||
|
||||
// UE_EUTRA_Capability->measParameters.bandListEUTRA.list.count = 0; // no measurements on other bands
|
||||
// UE_EUTRA_Capability->featureGroupIndicators // null
|
||||
|
||||
if (get_softmodem_params()->nsa && received_nr_msg)
|
||||
{
|
||||
allocate_en_DC_r15(UE_EUTRA_Capability);
|
||||
if (!is_en_dc_supported(UE_EUTRA_Capability)){
|
||||
LOG_E(RRC, "We did not properly allocate en_DC_r15 for UE_EUTRA_Capability\n");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
FILE *f = fopen(UE_EUTRA_Capability_xer_fname, "r");
|
||||
assert(f);
|
||||
|
||||
@@ -368,12 +368,10 @@ int do_HandoverPreparation(char *ho_buf, int ho_size, LTE_UE_EUTRA_Capability_t
|
||||
|
||||
int do_HandoverCommand(char *ho_buf, int ho_size, char *rrc_buf, int rrc_size);
|
||||
|
||||
OAI_UECapability_t *fill_ue_capability(char *LTE_UE_EUTRA_Capability_xer, bool received_nr_msg);
|
||||
OAI_UECapability_t *fill_ue_capability(char *LTE_UE_EUTRA_Capability_xer);
|
||||
|
||||
int is_en_dc_supported(LTE_UE_EUTRA_Capability_t *c);
|
||||
|
||||
void allocate_en_DC_r15(LTE_UE_EUTRA_Capability_t *cap);
|
||||
|
||||
uint8_t
|
||||
do_UECapabilityEnquiry(
|
||||
const protocol_ctxt_t *const ctxt_pP,
|
||||
|
||||
+2
-640
@@ -64,9 +64,6 @@
|
||||
#include "LTE_UECapabilityEnquiry.h"
|
||||
#include "LTE_UE-CapabilityRequest.h"
|
||||
|
||||
#include "NR_RAT-Type.h"
|
||||
#include "NR_UE-CapabilityRAT-Container.h"
|
||||
|
||||
#include "common/utils/tun_if.h"
|
||||
#if ENABLE_RAL
|
||||
#include "rrc_UE_ral.h"
|
||||
@@ -97,9 +94,6 @@
|
||||
//for D2D
|
||||
int ctrl_sock_fd;
|
||||
struct sockaddr_in prose_app_addr;
|
||||
static const char nsa_ipaddr[] = "127.0.0.1";
|
||||
static int from_nr_ue_fd = -1;
|
||||
static int to_nr_ue_fd = -1;
|
||||
int slrb_id;
|
||||
int send_ue_information = 0;
|
||||
// TimeToTrigger enum mapping table (36.331 TimeToTrigger IE)
|
||||
@@ -144,22 +138,10 @@ typedef struct rrc_dcch_data_copy_t
|
||||
LTE_DL_DCCH_Message_t *dl_dcch_msg;
|
||||
} rrc_dcch_data_copy_t;
|
||||
|
||||
typedef struct rrc_nrue_cap_info_t
|
||||
{
|
||||
uint8_t mesg[RRC_BUF_SIZE];
|
||||
size_t mesg_len;
|
||||
LTE_DL_DCCH_Message_t *dl_dcch_msg;
|
||||
} rrc_nrue_cap_info_t;
|
||||
|
||||
static void rrc_ue_process_ueCapabilityEnquiry(const protocol_ctxt_t *const ctxt_pP,
|
||||
LTE_UECapabilityEnquiry_t *UECapabilityEnquiry,
|
||||
uint8_t eNB_index);
|
||||
|
||||
static void rrc_ue_process_nrueCapabilityEnquiry(const protocol_ctxt_t *const ctxt_pP,
|
||||
LTE_UECapabilityEnquiry_t *UECapabilityEnquiry,
|
||||
rrc_nrue_cap_info_t *nrue_cap_info,
|
||||
uint8_t eNB_index);
|
||||
|
||||
/** \brief Generates/Encodes RRCConnnectionSetupComplete message at UE
|
||||
* \param ctxt_pP Running context
|
||||
* \param eNB_index Index of corresponding eNB/CH
|
||||
@@ -184,8 +166,6 @@ static void rrc_ue_generate_RRCConnectionReconfigurationComplete(const protocol_
|
||||
|
||||
static void rrc_ue_generate_MeasurementReport(protocol_ctxt_t *const ctxt_pP, uint8_t eNB_index );
|
||||
|
||||
static void rrc_ue_generate_nrMeasurementReport(protocol_ctxt_t *const ctxt_pP, uint8_t eNB_index );
|
||||
|
||||
static uint8_t check_trigger_meas_event(
|
||||
module_id_t module_idP,
|
||||
frame_t frameP,
|
||||
@@ -208,8 +188,6 @@ rrc_ue_process_MBMSCountingRequest(
|
||||
uint8_t eNB_index
|
||||
);
|
||||
|
||||
static void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len);
|
||||
static void nsa_sendmsg_to_nrue(const void *message, size_t msg_len, Rrc_Msg_Type_t msg_type);
|
||||
protocol_ctxt_t ctxt_pP_local;
|
||||
|
||||
|
||||
@@ -838,25 +816,6 @@ rrc_ue_process_measConfig(
|
||||
measObj->measObject.choice.measObjectEUTRA.allowedMeasBandwidth,
|
||||
measObj->measObject.choice.measObjectEUTRA.presenceAntennaPort1,
|
||||
measObj->measObject.choice.measObjectEUTRA.neighCellConfig.buf[0]);
|
||||
} else if (measObj->measObject.present == LTE_MeasObjectToAddMod__measObject_PR_measObjectNR_r15) {
|
||||
ue->subframeCount = 0;
|
||||
LOG_I(RRC, "NR_r15 Measurement: carrierFreq: %ld\n",
|
||||
measObj->measObject.choice.measObjectNR_r15.carrierFreq_r15);
|
||||
if (!get_softmodem_params()->nsa) {
|
||||
LOG_E(RRC, "Not in NSA mode but attempting to send measurement request to NR-UE\n");
|
||||
return;
|
||||
}
|
||||
uint8_t buffer[RRC_BUF_SIZE];
|
||||
asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_LTE_MeasObjectToAddMod,
|
||||
NULL,
|
||||
measObj,
|
||||
buffer,
|
||||
sizeof(buffer));
|
||||
AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %zu)!\n",
|
||||
enc_rval.failed_type->name, enc_rval.encoded);
|
||||
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;
|
||||
@@ -1697,102 +1656,6 @@ rrc_ue_process_MBMSCountingRequest(
|
||||
|
||||
}
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void
|
||||
rrc_ue_process_nrueCapabilityEnquiry(
|
||||
const protocol_ctxt_t *const ctxt_pP,
|
||||
LTE_UECapabilityEnquiry_t *UECapabilityEnquiry,
|
||||
rrc_nrue_cap_info_t *nrue_cap_info,
|
||||
uint8_t eNB_index
|
||||
)
|
||||
//-----------------------------------------------------------------------------
|
||||
{
|
||||
asn_enc_rval_t enc_rval;
|
||||
uint8_t buffer[RRC_BUF_SIZE];
|
||||
LOG_I(RRC,"[UE %d] Frame %d: Receiving from SRB1 (DL-DCCH), Processing NRUECapabilityEnquiry (eNB %d)\n",
|
||||
ctxt_pP->module_id,
|
||||
ctxt_pP->frame,
|
||||
eNB_index);
|
||||
LTE_UL_DCCH_Message_t ul_dcch_msg;
|
||||
memset(&ul_dcch_msg, 0, sizeof(ul_dcch_msg));
|
||||
LTE_UECapabilityInformation_t *ue_cap = &ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation;
|
||||
ul_dcch_msg.message.present = LTE_UL_DCCH_MessageType_PR_c1;
|
||||
ul_dcch_msg.message.choice.c1.present = LTE_UL_DCCH_MessageType__c1_PR_ueCapabilityInformation;
|
||||
ue_cap->rrc_TransactionIdentifier = UECapabilityEnquiry->rrc_TransactionIdentifier;
|
||||
|
||||
NR_UE_CapabilityRAT_Container_t ue_CapabilityRAT_Container;
|
||||
memset(&ue_CapabilityRAT_Container, 0, sizeof(ue_CapabilityRAT_Container));
|
||||
ue_CapabilityRAT_Container.rat_Type = NR_RAT_Type_nr;
|
||||
OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container.ue_CapabilityRAT_Container,
|
||||
(const char *)nrue_cap_info->mesg,
|
||||
nrue_cap_info->mesg_len);
|
||||
# if(1) // TODO: The MRDC capabilites should be filled in the NR UE
|
||||
NR_UE_CapabilityRAT_Container_t ue_CapabilityRAT_Container_mrdc;
|
||||
memset(&ue_CapabilityRAT_Container_mrdc, 0, sizeof(ue_CapabilityRAT_Container_mrdc));
|
||||
uint8_t buffer_mrdc[RRC_BUF_SIZE];
|
||||
NR_UE_MRDC_Capability_t *UE_Capability_MRDC = CALLOC(1, sizeof(NR_UE_MRDC_Capability_t));
|
||||
asn_enc_rval_t enc_rval_mrdc = uper_encode_to_buffer(&asn_DEF_NR_UE_MRDC_Capability,
|
||||
NULL,
|
||||
(void *)UE_Capability_MRDC,
|
||||
&buffer_mrdc,
|
||||
sizeof(buffer_mrdc));
|
||||
AssertFatal (enc_rval_mrdc.encoded > 0, "ASN1 message encoding failed (%s, %lu)!\n",
|
||||
enc_rval_mrdc.failed_type->name, enc_rval_mrdc.encoded);
|
||||
LOG_I(RRC, "[NR_RRC] NRUE MRDC Capability encoded, %ld bytes (%ld bits)\n",
|
||||
(enc_rval_mrdc.encoded + 7) / 8, enc_rval_mrdc.encoded + 7);
|
||||
|
||||
ue_CapabilityRAT_Container_mrdc.rat_Type = NR_RAT_Type_eutra_nr;
|
||||
OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container_mrdc.ue_CapabilityRAT_Container,
|
||||
(const char *)buffer_mrdc,
|
||||
(enc_rval_mrdc.encoded + 7) / 8);
|
||||
#endif
|
||||
|
||||
ue_cap->criticalExtensions.present = LTE_UECapabilityInformation__criticalExtensions_PR_c1;
|
||||
ue_cap->criticalExtensions.choice.c1.present = LTE_UECapabilityInformation__criticalExtensions__c1_PR_ueCapabilityInformation_r8;
|
||||
ue_cap->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.count = 0;
|
||||
int count = UECapabilityEnquiry->criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest.list.count;
|
||||
xer_fprint(stdout, &asn_DEF_NR_UE_CapabilityRAT_Container, (void *)&ue_CapabilityRAT_Container);
|
||||
LTE_UE_CapabilityRequest_t *cap_req = &UECapabilityEnquiry->criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest;
|
||||
for (int i = 0; i < count; i++) {
|
||||
enc_rval.encoded = 0;
|
||||
if (*cap_req->list.array[i] == LTE_RAT_Type_nr) {
|
||||
asn1cSeqAdd(&ue_cap->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list,
|
||||
&ue_CapabilityRAT_Container);
|
||||
ue_cap->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.array[i]->rat_Type = LTE_RAT_Type_nr;
|
||||
asn_enc_rval_t enc_rval_nr = uper_encode_to_buffer(&asn_DEF_LTE_UL_DCCH_Message, NULL, (void *) &ul_dcch_msg, buffer, sizeof(buffer));
|
||||
AssertFatal (enc_rval_nr.encoded > 0, "ASN1 message encoding failed (%s, %jd)!\n",
|
||||
enc_rval_nr.failed_type->name, enc_rval_nr.encoded);
|
||||
enc_rval.encoded = enc_rval.encoded + enc_rval_nr.encoded;
|
||||
xer_fprint(stdout, &asn_DEF_LTE_UL_DCCH_Message, (void *)&ul_dcch_msg);
|
||||
LOG_A(RRC, "%s: NR_UECapInfo LTE_RAT_Type_nr Encoded %zd bits (%zd bytes)\n",
|
||||
__FUNCTION__, enc_rval.encoded, (enc_rval.encoded+7)/8);
|
||||
}
|
||||
else if (*cap_req->list.array[i] == LTE_RAT_Type_eutra_nr) {
|
||||
asn1cSeqAdd(&ue_cap->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list,
|
||||
&ue_CapabilityRAT_Container_mrdc);
|
||||
ue_cap->criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list.array[i]->rat_Type = LTE_RAT_Type_eutra_nr;
|
||||
asn_enc_rval_t enc_rval_eutra_nr = uper_encode_to_buffer(&asn_DEF_LTE_UL_DCCH_Message, NULL, (void *) &ul_dcch_msg, buffer, sizeof(buffer));
|
||||
AssertFatal (enc_rval_eutra_nr.encoded > 0, "ASN1 message encoding failed (%s, %jd)!\n",
|
||||
enc_rval_eutra_nr.failed_type->name, enc_rval_eutra_nr.encoded);
|
||||
enc_rval.encoded = enc_rval.encoded + enc_rval_eutra_nr.encoded;
|
||||
xer_fprint(stdout, &asn_DEF_LTE_UL_DCCH_Message, (void *)&ul_dcch_msg);
|
||||
LOG_A(RRC, "%s: NR_UECapInfo LTE_RAT_Type_eutra_nr Encoded %zd bits (%zd bytes)\n",
|
||||
__FUNCTION__, enc_rval.encoded, (enc_rval.encoded+7)/8);
|
||||
}
|
||||
rrc_data_req_ue (
|
||||
ctxt_pP,
|
||||
DCCH,
|
||||
rrc_mui++,
|
||||
SDU_CONFIRM_NO,
|
||||
(enc_rval.encoded + 7) / 8,
|
||||
buffer,
|
||||
PDCP_TRANSMISSION_MODE_CONTROL);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void
|
||||
rrc_ue_process_ueCapabilityEnquiry(
|
||||
@@ -1861,57 +1724,9 @@ rrc_ue_process_ueCapabilityEnquiry(
|
||||
buffer,
|
||||
PDCP_TRANSMISSION_MODE_CONTROL);
|
||||
}
|
||||
else if (*UECapabilityEnquiry->criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest.list.array[i]
|
||||
== LTE_RAT_Type_nr) {
|
||||
asn1cSeqAdd(
|
||||
&ul_dcch_msg.message.choice.c1.choice.ueCapabilityInformation.criticalExtensions.choice.c1.choice.ueCapabilityInformation_r8.ue_CapabilityRAT_ContainerList.list,
|
||||
&ue_CapabilityRAT_Container);
|
||||
enc_rval = uper_encode_to_buffer(&asn_DEF_LTE_UL_DCCH_Message, NULL, (void *) &ul_dcch_msg, buffer, 100);
|
||||
AssertFatal (enc_rval.encoded > 0, "ASN1 message encoding failed (%s, %jd)!\n",
|
||||
enc_rval.failed_type->name, enc_rval.encoded);
|
||||
|
||||
if ( LOG_DEBUGFLAG(DEBUG_ASN1) ) {
|
||||
xer_fprint(stdout, &asn_DEF_LTE_UL_DCCH_Message, (void *)&ul_dcch_msg);
|
||||
}
|
||||
|
||||
LOG_A(RRC, "%s: NR_UECapabilityInformation Encoded %zd bits (%zd bytes)\n",
|
||||
__FUNCTION__, enc_rval.encoded,(enc_rval.encoded+7)/8);
|
||||
rrc_data_req_ue (
|
||||
ctxt_pP,
|
||||
DCCH,
|
||||
rrc_mui++,
|
||||
SDU_CONFIRM_NO,
|
||||
(enc_rval.encoded + 7) / 8,
|
||||
buffer,
|
||||
PDCP_TRANSMISSION_MODE_CONTROL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool is_nr_r15_config_present(LTE_RRCConnectionReconfiguration_r8_IEs_t *c)
|
||||
{
|
||||
#define NCE nonCriticalExtension
|
||||
#define chk(x) do { \
|
||||
if ((x) == NULL) { \
|
||||
LOG_I(RRC, "NULL at %d\n", __LINE__); \
|
||||
return false; \
|
||||
} \
|
||||
} while(0)
|
||||
chk(c);
|
||||
chk(c->NCE);
|
||||
chk(c->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE->NCE->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE->NCE->NCE->NCE->NCE);
|
||||
chk(c->NCE->NCE->NCE->NCE->NCE->NCE->NCE->NCE);
|
||||
return c->NCE->NCE->NCE->NCE->NCE->NCE->NCE->NCE->nr_Config_r15->present ==
|
||||
LTE_RRCConnectionReconfiguration_v1510_IEs__nr_Config_r15_PR_setup;
|
||||
|
||||
#undef NCE
|
||||
#undef chk
|
||||
}
|
||||
/** \brief process the received rrcConnectionReconfiguration message at UE
|
||||
\param ctxt_pP Running context
|
||||
\param *rrcConnectionReconfiguration pointer to the sturcture
|
||||
@@ -1932,42 +1747,6 @@ static void rrc_ue_process_rrcConnectionReconfiguration(const protocol_ctxt_t *c
|
||||
criticalExtensions.choice.c1.
|
||||
choice.rrcConnectionReconfiguration_r8;
|
||||
|
||||
if (is_nr_r15_config_present(r_r8)) {
|
||||
OCTET_STRING_t *nr_RadioBearer = r_r8->nonCriticalExtension->nonCriticalExtension->
|
||||
nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
|
||||
nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
|
||||
nr_RadioBearerConfig1_r15;
|
||||
OCTET_STRING_t *nr_SecondaryCellGroup = r_r8->nonCriticalExtension->nonCriticalExtension->
|
||||
nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
|
||||
nonCriticalExtension->nonCriticalExtension->nonCriticalExtension->
|
||||
nr_Config_r15->choice.setup.nr_SecondaryCellGroupConfig_r15;
|
||||
uint32_t total_size = nr_RadioBearer->size + nr_SecondaryCellGroup->size;
|
||||
struct msg {
|
||||
uint32_t RadioBearer_size;
|
||||
uint32_t SecondaryCellGroup_size;
|
||||
uint8_t trans_id;
|
||||
uint8_t padding[3];
|
||||
uint8_t *buffer;
|
||||
} msg;
|
||||
|
||||
msg.buffer = calloc(total_size, sizeof(*msg.buffer));
|
||||
AssertFatal(msg.buffer != NULL, "Error in memory allocation\n");
|
||||
msg.RadioBearer_size = nr_RadioBearer->size;
|
||||
msg.SecondaryCellGroup_size = nr_SecondaryCellGroup->size;
|
||||
msg.trans_id = rrcConnectionReconfiguration->rrc_TransactionIdentifier;
|
||||
memcpy(msg.buffer, nr_RadioBearer->buf, nr_RadioBearer->size);
|
||||
memcpy(msg.buffer + nr_RadioBearer->size, nr_SecondaryCellGroup->buf, nr_SecondaryCellGroup->size);
|
||||
|
||||
LOG_D(RRC, "nr_RadioBearerConfig1_r15 size %ld nr_SecondaryCellGroupConfig_r15 size %ld, sizeof(msg) = %zu\n",
|
||||
nr_RadioBearer->size,
|
||||
nr_SecondaryCellGroup->size,
|
||||
sizeof(msg));
|
||||
|
||||
nsa_sendmsg_to_nrue(&msg, sizeof(msg), RRC_CONFIG_COMPLETE_REQ);
|
||||
free(msg.buffer);
|
||||
LOG_A(RRC, "Sent RRC_CONFIG_COMPLETE_REQ to the NR UE\n");
|
||||
}
|
||||
|
||||
if (r_r8->mobilityControlInfo) {
|
||||
LOG_I(RRC,"Mobility Control Information is present\n");
|
||||
rrc_ue_process_mobilityControlInfo(
|
||||
@@ -2483,52 +2262,7 @@ static void rrc_ue_decode_dcch(const protocol_ctxt_t *const ctxt_pP,
|
||||
ctxt_pP->module_id,
|
||||
eNB_indexP);
|
||||
|
||||
LTE_UE_CapabilityRequest_t *ue_cap = &dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry.criticalExtensions.
|
||||
choice.c1.choice.ueCapabilityEnquiry_r8.ue_CapabilityRequest;
|
||||
bool have_received_nrue_cap = false;
|
||||
for (int i = 0; i < ue_cap->list.count; i++) {
|
||||
if (*ue_cap->list.array[i] == LTE_RAT_Type_nr || *ue_cap->list.array[i] == LTE_RAT_Type_eutra_nr) {
|
||||
have_received_nrue_cap = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (have_received_nrue_cap) {
|
||||
LTE_UECapabilityEnquiry_t *ueCapabilityEnquiry_nsa = &dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry;
|
||||
OCTET_STRING_t * requestedFreqBandsNR = ueCapabilityEnquiry_nsa->
|
||||
criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.nonCriticalExtension->
|
||||
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) {
|
||||
info->dl_dcch_msg = NULL;
|
||||
}
|
||||
info->dl_dcch_msg = dl_dcch_msg;
|
||||
dl_dcch_msg = NULL;
|
||||
} else if (get_softmodem_params()->nsa && !have_received_nrue_cap) {
|
||||
LTE_UECapabilityEnquiry_t *ueCapabilityEnquiry_nsa = &dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry;
|
||||
OCTET_STRING_t * requestedFreqBandsNR = ueCapabilityEnquiry_nsa->
|
||||
criticalExtensions.choice.c1.choice.ueCapabilityEnquiry_r8.nonCriticalExtension->
|
||||
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) {
|
||||
info->dl_dcch_msg = NULL;
|
||||
}
|
||||
info->dl_dcch_msg = dl_dcch_msg;
|
||||
dl_dcch_msg = NULL;
|
||||
} else {
|
||||
rrc_ue_process_ueCapabilityEnquiry(
|
||||
ctxt_pP,
|
||||
&dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry,
|
||||
eNB_indexP);
|
||||
}
|
||||
rrc_ue_process_ueCapabilityEnquiry(ctxt_pP, &dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry, eNB_indexP);
|
||||
break;
|
||||
|
||||
case LTE_DL_DCCH_MessageType__c1_PR_counterCheck:
|
||||
@@ -4285,43 +4019,6 @@ void ue_meas_filtering( const protocol_ctxt_t *const ctxt_pP, const uint8_t eNB_
|
||||
}
|
||||
}
|
||||
}
|
||||
//Below routine implements Measurement Reporting procedure from 36.331 Section 5.5.5
|
||||
//-----------------------------------------------------------------------------
|
||||
void rrc_ue_generate_nrMeasurementReport(protocol_ctxt_t *const ctxt_pP, uint8_t eNB_index ) {
|
||||
uint8_t buffer[RRC_BUF_SIZE];
|
||||
UE_RRC_INST *ue = &UE_rrc_inst[ctxt_pP->module_id];
|
||||
uint8_t target_eNB_offset = ue->Info[0].handoverTarget;
|
||||
LTE_PhysCellId_t targetCellId = ue->HandoverInfoUe.targetCellId;
|
||||
|
||||
for (int i = 0; i < MAX_MEAS_ID; i++) {
|
||||
if (ue->measReportList[eNB_index][i] != NULL) {
|
||||
LTE_MeasId_t measId = ue->measReportList[eNB_index][i]->measId;
|
||||
long rsrp_s = binary_search_float(RSRP_meas_mapping, 98, ue->rsrp_db_filtered[eNB_index]);
|
||||
long rsrq_s = binary_search_float(RSRQ_meas_mapping, 35, ue->rsrq_db_filtered[eNB_index]);
|
||||
long rsrp_tar = binary_search_float(RSRP_meas_mapping, 98, ue->rsrp_db_filtered[target_eNB_offset]);
|
||||
long rsrq_tar = binary_search_float(RSRQ_meas_mapping, 35, ue->rsrq_db_filtered[target_eNB_offset]);
|
||||
|
||||
LOG_I(RRC,"[UE %d] Frame %d: source eNB: %d target eNB: %d servingCell(%d) targetCell(%ld)\n",
|
||||
ctxt_pP->module_id,
|
||||
ctxt_pP->frame,
|
||||
eNB_index,
|
||||
target_eNB_offset,
|
||||
get_adjacent_cell_id(ctxt_pP->module_id, eNB_index),
|
||||
targetCellId);
|
||||
|
||||
if (ctxt_pP->frame != 0) {
|
||||
LOG_I(RRC, "measId %ld, targetCellId %ld, rsrp_s %ld, rsrq_s %ld, rsrp_t %ld, rsrq_t %ld\n",
|
||||
measId, targetCellId, rsrp_s, rsrq_s, rsrp_tar, rsrq_tar);
|
||||
ssize_t size = do_nrMeasurementReport(buffer, sizeof(buffer), measId, targetCellId, rsrp_s, rsrq_s, rsrp_tar, rsrq_tar);
|
||||
AssertFatal(size >= 0, "do_nrMeasurementReport failed \n");
|
||||
LOG_I(RRC, "[UE %d] Frame %d : Generating Measurement Report for eNB %d\n",
|
||||
ctxt_pP->module_id, ctxt_pP->frame, eNB_index);
|
||||
const bool result = pdcp_data_req(ctxt_pP, SRB_FLAG_YES, DCCH, rrc_mui++, 0, size, buffer, PDCP_TRANSMISSION_MODE_DATA,NULL, NULL);
|
||||
AssertFatal (result == true, "PDCP data request failed!\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//Below routine implements Measurement Reporting procedure from 36.331 Section 5.5.5
|
||||
//-----------------------------------------------------------------------------
|
||||
@@ -4395,39 +4092,6 @@ void rrc_ue_generate_MeasurementReport(protocol_ctxt_t *const ctxt_pP, uint8_t e
|
||||
}
|
||||
}
|
||||
|
||||
static bool does_rrcConnReconfig_have_nr(const UE_RRC_INST *ue) {
|
||||
for (int i = 0; i < NB_CNX_UE; i++) {
|
||||
for (int j = 0; j < MAX_MEAS_ID; j++) {
|
||||
LTE_ReportConfigId_t reportConfigId = ue->MeasId[i][j]->reportConfigId;
|
||||
AssertFatal(reportConfigId >= 1 && reportConfigId <= MAX_MEAS_CONFIG, "Bad index\n");
|
||||
const LTE_ReportConfigToAddMod_t *rc = ue->ReportConfig[i][reportConfigId-1];
|
||||
if (rc == NULL) {
|
||||
LOG_D(RRC, "UE_rrc_inst[ctxt_pP->module_id]->ReportConfig[%d][%ld] = NULL\n", i, reportConfigId-1);
|
||||
continue;
|
||||
}
|
||||
if (rc->reportConfig.present != LTE_ReportConfigToAddMod__reportConfig_PR_reportConfigInterRAT) {
|
||||
LOG_D(RRC, "reportConfig.present = %d, not LTE_ReportConfigToAddMod__reportConfig_PR_reportConfigInterRAT\n",
|
||||
rc->reportConfig.present);
|
||||
continue;
|
||||
}
|
||||
LTE_ReportConfigInterRAT_t irat = rc->reportConfig.choice.reportConfigInterRAT;
|
||||
if (irat.triggerType.present != LTE_ReportConfigInterRAT__triggerType_PR_event) {
|
||||
LOG_D(RRC, "irat.triggerType.present = %d, not LTE_ReportConfigInterRAT__triggerType_PR_event\n",
|
||||
irat.triggerType.present);
|
||||
continue;
|
||||
}
|
||||
if (irat.triggerType.choice.event.eventId.present != LTE_ReportConfigInterRAT__triggerType__event__eventId_PR_eventB1_NR_r15) {
|
||||
LOG_D(RRC, "irat.triggerType.choice.event.eventId.present = %d\n",
|
||||
irat.triggerType.choice.event.eventId.present);
|
||||
continue;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// Measurement report triggering, described in 36.331 Section 5.5.4.1: called periodically
|
||||
//-----------------------------------------------------------------------------
|
||||
void ue_measurement_report_triggering(protocol_ctxt_t *const ctxt_pP, const uint8_t eNB_index ) {
|
||||
@@ -4528,49 +4192,6 @@ void ue_measurement_report_triggering(protocol_ctxt_t *const ctxt_pP, const uint
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (ue->MeasObj[i][measObjId-1]->measObject.present == LTE_MeasObjectToAddMod__measObject_PR_measObjectNR_r15) {
|
||||
if (!does_rrcConnReconfig_have_nr(ue))
|
||||
break;
|
||||
LTE_ReportConfigInterRAT_t *rc = &ue->ReportConfig[i][reportConfigId-1]->reportConfig.choice.reportConfigInterRAT;
|
||||
LTE_TimeToTrigger_t trig_per = rc->triggerType.choice.event.timeToTrigger;
|
||||
ttt_ms = timeToTrigger_ms[trig_per];
|
||||
LOG_D(RRC, "[UE %d] Frame %d: B1_NR_r15 event. count %d, ttt %ld\n",
|
||||
ctxt_pP->module_id, ctxt_pP->frame, ue->subframeCount, ttt_ms);
|
||||
if (ue->subframeCount < ttt_ms) {
|
||||
++ue->subframeCount;
|
||||
break;
|
||||
}
|
||||
ue->subframeCount = 0;
|
||||
bool is_state_connected = false;
|
||||
bool is_t304_inactive = false;
|
||||
bool have_meas_flag = false;
|
||||
if (ue->Info[0].State >= RRC_CONNECTED)
|
||||
is_state_connected = true;
|
||||
if (ue->Info[0].T304_active == 0)
|
||||
is_t304_inactive = true;
|
||||
if (ue->HandoverInfoUe.measFlag == 1)
|
||||
have_meas_flag = true;
|
||||
|
||||
if (is_state_connected && is_t304_inactive && have_meas_flag) {
|
||||
LOG_I(RRC,"[UE %d] Frame %d: Triggering generation of Meas Report for NR_r15. count = %d\n",
|
||||
ctxt_pP->module_id, ctxt_pP->frame, ue->subframeCount);
|
||||
if (ue->measReportList[i][j] == NULL) {
|
||||
ue->measReportList[i][j] = malloc(sizeof(MEAS_REPORT_LIST));
|
||||
}
|
||||
ue->measReportList[i][j]->measId = ue->MeasId[i][j]->measId;
|
||||
ue->measReportList[i][j]->numberOfReportsSent = 0;
|
||||
rrc_ue_generate_nrMeasurementReport(ctxt_pP, eNB_index);
|
||||
ue->HandoverInfoUe.measFlag = 1;
|
||||
LOG_I(RRC,"[UE %d] Frame %d: RSRB detected, state: %d \n",
|
||||
ctxt_pP->module_id, ctxt_pP->frame, ue->Info[0].State);
|
||||
} else {
|
||||
if(ue->measReportList[i][j] != NULL) {
|
||||
free(ue->measReportList[i][j]);
|
||||
}
|
||||
ue->measReportList[i][j] = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4970,38 +4591,6 @@ void *rrc_ue_task( void *args_p ) {
|
||||
break;
|
||||
}
|
||||
|
||||
case RRC_NRUE_CAP_INFO_IND:
|
||||
{
|
||||
PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, RRC_NRUE_CAP_INFO_IND (msg_p).module_id,
|
||||
ENB_FLAG_NO, RRC_NRUE_CAP_INFO_IND (msg_p).rnti,
|
||||
RRC_NRUE_CAP_INFO_IND (msg_p).frame,
|
||||
0,
|
||||
RRC_NRUE_CAP_INFO_IND (msg_p).eNB_index);
|
||||
LOG_I(RRC, "[UE %d] Received %s. Now calling rrc_ue_process_nrueCapabilityEnquiry\n",
|
||||
ue_mod_id, ITTI_MSG_NAME (msg_p));
|
||||
rrc_nrue_cap_info_t *nrue_cap_info = (void *)RRC_NRUE_CAP_INFO_IND (msg_p).sdu_p;
|
||||
AssertFatal(RRC_NRUE_CAP_INFO_IND (msg_p).sdu_size == sizeof(*nrue_cap_info), "Size of nrue_cap_info incorrect\n");
|
||||
rrc_ue_process_nrueCapabilityEnquiry(
|
||||
&ctxt,
|
||||
&nrue_cap_info->dl_dcch_msg->message.choice.c1.choice.ueCapabilityEnquiry,
|
||||
nrue_cap_info,
|
||||
RRC_NRUE_CAP_INFO_IND (msg_p).eNB_index);
|
||||
SEQUENCE_free(&asn_DEF_LTE_DL_DCCH_Message, nrue_cap_info->dl_dcch_msg, ASFM_FREE_EVERYTHING);
|
||||
result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), RRC_NRUE_CAP_INFO_IND (msg_p).sdu_p);
|
||||
AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
|
||||
break;
|
||||
}
|
||||
case NAS_OAI_TUN_NSA:
|
||||
{
|
||||
LOG_D(NAS, "Received %s: length %lu. About to send this to the NR UE\n", ITTI_MSG_NAME (msg_p),
|
||||
sizeof(NAS_OAI_TUN_NSA (msg_p).buffer));
|
||||
char buffer[RRC_BUF_SIZE];
|
||||
memcpy(buffer, NAS_OAI_TUN_NSA(msg_p).buffer, sizeof(buffer));
|
||||
nsa_sendmsg_to_nrue(buffer, sizeof(buffer), OAI_TUN_IFACE_NSA);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
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 = "
|
||||
@@ -5331,8 +4920,7 @@ openair_rrc_top_init_ue(
|
||||
memset (UE_rrc_inst, 0, NB_UE_INST * sizeof(UE_RRC_INST));
|
||||
LOG_D(RRC, "ALLOCATE %d Bytes for UE_RRC_INST @ %p\n", (unsigned int)(NB_UE_INST*sizeof(UE_RRC_INST)), UE_rrc_inst);
|
||||
// fill UE capability
|
||||
bool received_nr_msg = false;
|
||||
UECap = fill_ue_capability (uecap_xer, received_nr_msg);
|
||||
UECap = fill_ue_capability (uecap_xer);
|
||||
|
||||
for (module_id = 0; module_id < NB_UE_INST; module_id++) {
|
||||
UE_rrc_inst[module_id].UECap = UECap;
|
||||
@@ -6405,229 +5993,3 @@ rrc_rx_tx_ue(
|
||||
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RRC_RX_TX,VCD_FUNCTION_OUT);
|
||||
return (RRC_OK);
|
||||
}
|
||||
|
||||
void *recv_msgs_from_nr_ue(void *args_p)
|
||||
{
|
||||
itti_mark_task_ready (TASK_RRC_NSA_UE);
|
||||
for (;;)
|
||||
{
|
||||
nsa_msg_t msg;
|
||||
int recvLen = recvfrom(from_nr_ue_fd, &msg, sizeof(msg),
|
||||
MSG_WAITALL | MSG_TRUNC, NULL, NULL);
|
||||
if (recvLen == -1)
|
||||
{
|
||||
LOG_E(RRC, "%s: recvfrom: %s\n", __func__, strerror(errno));
|
||||
continue;
|
||||
}
|
||||
if (recvLen > sizeof(msg))
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: Received a truncated message %d\n", __func__, recvLen);
|
||||
continue;
|
||||
}
|
||||
LOG_D(RRC, "We have received a %d msg (%d bytes). Calling process_nr_nsa_msg\n", msg.msg_type, recvLen);
|
||||
process_nr_nsa_msg(&msg, recvLen);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void nsa_sendmsg_to_nrue(const void *message, size_t msg_len, Rrc_Msg_Type_t msg_type)
|
||||
{
|
||||
LOG_I(RRC, "Entered %s \n", __FUNCTION__);
|
||||
nsa_msg_t n_msg;
|
||||
if (msg_len > sizeof(n_msg.msg_buffer))
|
||||
{
|
||||
LOG_E(RRC, "%s: message too big: %zu\n", __func__, msg_len);
|
||||
abort();
|
||||
}
|
||||
n_msg.msg_type = msg_type;
|
||||
memcpy(n_msg.msg_buffer, message, msg_len);
|
||||
size_t to_send = sizeof(n_msg.msg_type) + msg_len;
|
||||
|
||||
struct sockaddr_in sa =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons(6008 + ue_id_g * 2),
|
||||
};
|
||||
int sent = sendto(to_nr_ue_fd, &n_msg, to_send, 0,
|
||||
(struct sockaddr *)&sa, sizeof(sa));
|
||||
if (sent == -1)
|
||||
{
|
||||
LOG_E(RRC, "%s: sendto: %s\n", __func__, strerror(errno));
|
||||
return;
|
||||
}
|
||||
if (sent != to_send)
|
||||
{
|
||||
LOG_E(RRC, "%s: Short send %d != %zu\n", __func__, sent, to_send);
|
||||
return;
|
||||
}
|
||||
LOG_I(RRC, "Sent a %d message to the nrUE (%d bytes) \n", msg_type, sent);
|
||||
}
|
||||
|
||||
void init_connections_with_nr_ue()
|
||||
{
|
||||
struct sockaddr_in sa =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons(6007 + ue_id_g * 2),
|
||||
};
|
||||
AssertFatal(from_nr_ue_fd == -1, "from_nr_ue_fd was assigned already");
|
||||
from_nr_ue_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (from_nr_ue_fd == -1)
|
||||
{
|
||||
LOG_E(RRC, "%s: Error opening socket %d (%d:%s)\n", __FUNCTION__, from_nr_ue_fd, errno, strerror(errno));
|
||||
abort();
|
||||
}
|
||||
|
||||
if (inet_aton(nsa_ipaddr, &sa.sin_addr) == 0)
|
||||
{
|
||||
LOG_E(RRC, "Bad nsa_ipaddr '%s'\n", nsa_ipaddr);
|
||||
abort();
|
||||
}
|
||||
|
||||
if (bind(from_nr_ue_fd, (struct sockaddr *) &sa, sizeof(sa)) == -1)
|
||||
{
|
||||
LOG_E(RRC,"%s: Failed to bind the socket\n", __FUNCTION__);
|
||||
abort();
|
||||
}
|
||||
|
||||
AssertFatal(to_nr_ue_fd == -1, "to_nr_ue_fd was assigned already");
|
||||
to_nr_ue_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (to_nr_ue_fd == -1)
|
||||
{
|
||||
LOG_E(RRC, "%s: Error opening socket %d (%d:%s)\n", __FUNCTION__, to_nr_ue_fd, errno, strerror(errno));
|
||||
abort();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void process_nr_nsa_msg(nsa_msg_t *msg, int msg_len)
|
||||
{
|
||||
if (msg_len < sizeof(msg->msg_type))
|
||||
{
|
||||
LOG_E(RRC, "Msg_len = %d\n", msg_len);
|
||||
return;
|
||||
}
|
||||
LOG_D(RRC, "We are processing an NSA message %d \n", msg->msg_type);
|
||||
Rrc_Msg_Type_t msg_type = msg->msg_type;
|
||||
uint8_t *const msg_buffer = msg->msg_buffer;
|
||||
msg_len -= sizeof(msg->msg_type);
|
||||
bool received_nr_msg = true;
|
||||
protocol_ctxt_t ctxt;
|
||||
module_id_t module_id = 0;
|
||||
eNB_index_t eNB_index = 0;
|
||||
|
||||
switch (msg_type)
|
||||
{
|
||||
case NRUE_CAPABILITY_INFO:
|
||||
{
|
||||
LOG_I(RRC, "Create itti msg to send received NRUE_CAPABILITY_INFO to eNB\n");
|
||||
|
||||
MessageDef *message_p;
|
||||
rrc_nrue_cap_info_t *nrue_cap_buf = itti_malloc (TASK_RRC_NSA_UE,
|
||||
TASK_RRC_UE,
|
||||
sizeof(rrc_nrue_cap_info_t));
|
||||
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[module_id].Info[eNB_index];
|
||||
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);
|
||||
RRC_NRUE_CAP_INFO_IND (message_p).sdu_p = (void *)nrue_cap_buf;
|
||||
RRC_NRUE_CAP_INFO_IND (message_p).sdu_size = sizeof(*nrue_cap_buf);
|
||||
RRC_NRUE_CAP_INFO_IND (message_p).module_id = module_id;
|
||||
RRC_NRUE_CAP_INFO_IND (message_p).rnti = info->rnti;
|
||||
RRC_NRUE_CAP_INFO_IND (message_p).eNB_index = eNB_index;
|
||||
itti_send_msg_to_task (TASK_RRC_UE, 0, message_p);
|
||||
LOG_I(RRC, "Sent itti RRC_NRUE_CAP_INFO_IND\n");
|
||||
break;
|
||||
}
|
||||
case UE_CAPABILITY_DUMMY:
|
||||
{
|
||||
fill_ue_capability(NULL, received_nr_msg);
|
||||
UE_rrc_inst[module_id].UECap = UE_rrc_inst->UECap;
|
||||
if (!is_en_dc_supported(UE_rrc_inst->UECap->UE_EUTRA_Capability))
|
||||
{
|
||||
LOG_E(RRC, "en_dc is NOT supported! Not sending RRC_DCCH_DATA_COPY_IND to update UE_Capability_INFO\n");
|
||||
break;
|
||||
}
|
||||
|
||||
LOG_I(RRC, "Send itti msg to trigger processing of capabilites b/c we have a UE_CAPABILITY_DUMMY\n");
|
||||
MessageDef *message_p;
|
||||
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[module_id].Info[eNB_index];
|
||||
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);
|
||||
RRC_DCCH_DATA_COPY_IND (message_p).sdu_p = (void *)dl_dcch_buffer;
|
||||
RRC_DCCH_DATA_COPY_IND (message_p).sdu_size = sizeof(rrc_dcch_data_copy_t);
|
||||
RRC_DCCH_DATA_COPY_IND (message_p).module_id = module_id;
|
||||
RRC_DCCH_DATA_COPY_IND (message_p).rnti = info->rnti;
|
||||
RRC_DCCH_DATA_COPY_IND (message_p).eNB_index = eNB_index;
|
||||
itti_send_msg_to_task (TASK_RRC_UE, 0, message_p);
|
||||
LOG_I(RRC, "Sent itti RRC_DCCH_DATA_COPY_IND\n");
|
||||
break;
|
||||
}
|
||||
|
||||
case NR_UE_RRC_MEASUREMENT:
|
||||
{
|
||||
nfapi_p7_message_header_t header;
|
||||
if (nfapi_p7_message_header_unpack((void *)msg_buffer, msg_len, &header, sizeof(header), NULL) < 0)
|
||||
{
|
||||
LOG_E(MAC, "Header unpack failed in %s \n", __FUNCTION__);
|
||||
break;
|
||||
}
|
||||
if (header.message_id != NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST)
|
||||
{
|
||||
LOG_E(MAC, "%s: Unexpected nfapi message type: %d\n", __FUNCTION__, header.message_id);
|
||||
break;
|
||||
}
|
||||
|
||||
nfapi_nr_dl_tti_request_t dl_tti_request;
|
||||
const bool result =
|
||||
nfapi_nr_p7_message_unpack((void *)msg_buffer, msg_len, &dl_tti_request, sizeof(nfapi_nr_dl_tti_request_t), NULL);
|
||||
if (!result) {
|
||||
LOG_E(RRC, "%s: SSB PDU unpack failed \n", __FUNCTION__);
|
||||
break;
|
||||
}
|
||||
int num_pdus = dl_tti_request.dl_tti_request_body.nPDUs;
|
||||
if (num_pdus <= 0)
|
||||
{
|
||||
LOG_E(RRC, "%s: dl_tti_request number of PDUS <= 0\n", __FUNCTION__);
|
||||
abort();
|
||||
}
|
||||
for (int i = 0; i < num_pdus; i++)
|
||||
{
|
||||
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(RRC, "Got an NR_UE_RRC_MEASUREMENT. pdulist[%d].ssbRsrp = %d\n",
|
||||
i, pdu_list->ssb_pdu.ssb_pdu_rel15.ssbRsrp);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case NR_RRC_CONFIG_COMPLETE_REQ:
|
||||
{
|
||||
LOG_I(RRC, "Got an NR_RRC_CONFIG_COMPLETE_REQ. Now make octet string and call below!\n");
|
||||
OCTET_STRING_t rrcConfigurationComplete;
|
||||
memset(&rrcConfigurationComplete, 0, sizeof(rrcConfigurationComplete));
|
||||
OCTET_STRING_fromBuf(&rrcConfigurationComplete,
|
||||
(const char *)msg_buffer,
|
||||
msg_len);
|
||||
UE_RRC_INFO *info = &UE_rrc_inst[module_id].Info[eNB_index];
|
||||
uint8_t t_id = info->dl_dcch_msg->message.choice.c1.choice.
|
||||
rrcConnectionReconfiguration.rrc_TransactionIdentifier;
|
||||
PROTOCOL_CTXT_SET_BY_MODULE_ID(&ctxt, module_id,
|
||||
ENB_FLAG_NO, info->rnti,
|
||||
0, 0, eNB_index);
|
||||
rrc_ue_generate_RRCConnectionReconfigurationComplete(&ctxt, ctxt.eNB_index, t_id, &rrcConfigurationComplete);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
LOG_E(RRC, "No NSA Message Found\n");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6354,7 +6354,7 @@ rrc_eNB_decode_dcch(
|
||||
/*NN: revise the condition */
|
||||
/*FK: left the condition as is for the case MME is used (S1 mode) but setting dedicated_DRB = 1 otherwise (noS1 mode) so that no second RRCReconfiguration message activationg more DRB is sent as this causes problems with the nasmesh driver.*/
|
||||
|
||||
if (!IS_SOFTMODEM_NOS1 || get_softmodem_params()->emulate_l1) {
|
||||
if (!IS_SOFTMODEM_NOS1) {
|
||||
if (ue_context_p->ue_context.StatusRrc == RRC_RECONFIGURED) {
|
||||
dedicated_DRB = 1;
|
||||
LOG_I(RRC,
|
||||
|
||||
@@ -331,12 +331,6 @@ void *rrc_enb_task(void *args_p);
|
||||
\param args_p Pointer on arguments to start the task. */
|
||||
void *rrc_ue_task(void *args_p);
|
||||
|
||||
/**\brief RRC NSA UE task.
|
||||
\param args_p Pointer on arguments to start the task. */
|
||||
void *recv_msgs_from_nr_ue(void *args_p);
|
||||
|
||||
void init_connections_with_nr_ue(void);
|
||||
|
||||
void rrc_eNB_process_x2_setup_request(int mod_id, x2ap_setup_req_t *m);
|
||||
|
||||
void rrc_eNB_process_x2_setup_response(int mod_id, x2ap_setup_resp_t *m);
|
||||
|
||||
@@ -47,7 +47,6 @@ void nr_mac_rrc_inactivity_timer_ind(const module_id_t mod_id);
|
||||
void nr_mac_rrc_msg3_ind(const module_id_t mod_id, const int rnti, bool prepare_payload);
|
||||
void nr_ue_rrc_timer_trigger(int instance, int frame, int gnb_id);
|
||||
void nr_mac_rrc_ra_ind(const module_id_t mod_id, bool success);
|
||||
void nsa_sendmsg_to_lte_ue(const void *message, size_t msg_len, Rrc_Msg_Type_t msg_type);
|
||||
void process_msg_rcc_to_mac(nr_mac_rrc_message_t *msg, int instance_id);
|
||||
#endif
|
||||
|
||||
|
||||
@@ -140,7 +140,6 @@ static void nr_rrc_manage_rlc_bearers(NR_UE_RRC_INST_t *rrc,
|
||||
static void nr_rrc_ue_process_RadioBearerConfig(NR_UE_RRC_INST_t *ue_rrc,
|
||||
NR_RadioBearerConfig_t *const radioBearerConfig);
|
||||
static void nr_rrc_ue_generate_rrcReestablishmentComplete(const NR_UE_RRC_INST_t *rrc, const NR_RRCReestablishment_t *rrcReestablishment);
|
||||
static void process_lte_nsa_msg(NR_UE_RRC_INST_t *rrc, nsa_msg_t *msg, int msg_len);
|
||||
static void nr_rrc_ue_process_ueCapabilityEnquiry(NR_UE_RRC_INST_t *rrc, NR_UECapabilityEnquiry_t *UECapabilityEnquiry);
|
||||
static void nr_rrc_ue_process_masterCellGroup(NR_UE_RRC_INST_t *rrc,
|
||||
OCTET_STRING_t *masterCellGroup,
|
||||
@@ -2712,10 +2711,6 @@ static void nr_rrc_ue_process_ueCapabilityEnquiry(NR_UE_RRC_INST_t *rrc, NR_UECa
|
||||
ue_CapabilityRAT_Container->rat_Type = NR_RAT_Type_nr;
|
||||
OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container->ue_CapabilityRAT_Container, (const char *)rrc->UECap.sdu, rrc->UECap.sdu_size);
|
||||
NR_UECapabilityEnquiry_IEs_t *ueCapabilityEnquiry_ie = UECapabilityEnquiry->criticalExtensions.choice.ueCapabilityEnquiry;
|
||||
if (get_softmodem_params()->nsa == 1) {
|
||||
OCTET_STRING_t *requestedFreqBandsNR = ueCapabilityEnquiry_ie->ue_CapabilityEnquiryExt;
|
||||
nsa_sendmsg_to_lte_ue(requestedFreqBandsNR->buf, requestedFreqBandsNR->size, UE_CAPABILITY_INFO);
|
||||
}
|
||||
// ue_CapabilityRAT_Container.ueCapabilityRAT_Container.buf = UE_rrc_inst[ue_mod_idP].UECapability;
|
||||
// ue_CapabilityRAT_Container.ueCapabilityRAT_Container.size = UE_rrc_inst[ue_mod_idP].UECapability_size;
|
||||
AssertFatal(UECapabilityEnquiry->criticalExtensions.present == NR_UECapabilityEnquiry__criticalExtensions_PR_ueCapabilityEnquiry,
|
||||
@@ -2798,183 +2793,6 @@ static void nr_rrc_ue_generate_rrcReestablishmentComplete(const NR_UE_RRC_INST_t
|
||||
nr_pdcp_data_req_srb(rrc->ue_id, srb_id, 0, size, buffer, deliver_pdu_srb_rlc, NULL);
|
||||
}
|
||||
|
||||
void *recv_msgs_from_lte_ue(void *args_p)
|
||||
{
|
||||
itti_mark_task_ready (TASK_RRC_NSA_NRUE);
|
||||
int from_lte_ue_fd = get_from_lte_ue_fd();
|
||||
for (;;) {
|
||||
nsa_msg_t msg;
|
||||
int recvLen = recvfrom(from_lte_ue_fd, &msg, sizeof(msg), MSG_WAITALL | MSG_TRUNC, NULL, NULL);
|
||||
if (recvLen == -1) {
|
||||
LOG_E(NR_RRC, "%s: recvfrom: %s\n", __func__, strerror(errno));
|
||||
continue;
|
||||
}
|
||||
if (recvLen > sizeof(msg)) {
|
||||
LOG_E(NR_RRC, "%s: Received truncated message %d\n", __func__, recvLen);
|
||||
continue;
|
||||
}
|
||||
process_lte_nsa_msg(get_NR_UE_rrc_inst(0), &msg, recvLen);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void nsa_rrc_ue_process_ueCapabilityEnquiry(NR_UE_RRC_INST_t *rrc)
|
||||
{
|
||||
NR_UE_NR_Capability_t *UE_Capability_nr = rrc->UECap.UE_NR_Capability = CALLOC(1, sizeof(NR_UE_NR_Capability_t));
|
||||
NR_BandNR_t *nr_bandnr = CALLOC(1, sizeof(NR_BandNR_t));
|
||||
nr_bandnr->bandNR = 78;
|
||||
asn1cSeqAdd(&UE_Capability_nr->rf_Parameters.supportedBandListNR.list, nr_bandnr);
|
||||
OAI_NR_UECapability_t *UECap = CALLOC(1, sizeof(OAI_NR_UECapability_t));
|
||||
UECap->UE_NR_Capability = UE_Capability_nr;
|
||||
|
||||
asn_enc_rval_t enc_rval = uper_encode_to_buffer(&asn_DEF_NR_UE_NR_Capability,
|
||||
NULL,
|
||||
(void *)UE_Capability_nr,
|
||||
&UECap->sdu[0],
|
||||
MAX_UE_NR_CAPABILITY_SIZE);
|
||||
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_A(NR_RRC, "[NR_RRC] NRUE Capability encoded, %d bytes (%zd bits)\n",
|
||||
UECap->sdu_size, enc_rval.encoded + 7);
|
||||
|
||||
NR_UE_CapabilityRAT_Container_t ue_CapabilityRAT_Container;
|
||||
memset(&ue_CapabilityRAT_Container, 0, sizeof(NR_UE_CapabilityRAT_Container_t));
|
||||
ue_CapabilityRAT_Container.rat_Type = NR_RAT_Type_nr;
|
||||
OCTET_STRING_fromBuf(&ue_CapabilityRAT_Container.ue_CapabilityRAT_Container,
|
||||
(const char *)rrc->UECap.sdu,
|
||||
rrc->UECap.sdu_size);
|
||||
|
||||
nsa_sendmsg_to_lte_ue(ue_CapabilityRAT_Container.ue_CapabilityRAT_Container.buf,
|
||||
ue_CapabilityRAT_Container.ue_CapabilityRAT_Container.size,
|
||||
NRUE_CAPABILITY_INFO);
|
||||
}
|
||||
|
||||
static void process_lte_nsa_msg(NR_UE_RRC_INST_t *rrc, nsa_msg_t *msg, int msg_len)
|
||||
{
|
||||
if (msg_len < sizeof(msg->msg_type)) {
|
||||
LOG_E(RRC, "Msg_len = %d\n", msg_len);
|
||||
return;
|
||||
}
|
||||
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);
|
||||
switch (msg_type) {
|
||||
case UE_CAPABILITY_ENQUIRY: {
|
||||
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,
|
||||
(void **)&nr_freq_band_list,
|
||||
msg_buffer,
|
||||
msg_len);
|
||||
if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
|
||||
SEQUENCE_free(&asn_DEF_NR_FreqBandList, nr_freq_band_list, ASFM_FREE_EVERYTHING);
|
||||
LOG_E(RRC, "Failed to decode UECapabilityInfo (%zu bits)\n", dec_rval.consumed);
|
||||
break;
|
||||
}
|
||||
for (int i = 0; i < nr_freq_band_list->list.count; i++) {
|
||||
LOG_D(NR_RRC, "Received NR band information: %ld.\n",
|
||||
nr_freq_band_list->list.array[i]->choice.bandInformationNR->bandNR);
|
||||
}
|
||||
int dummy_msg = 0;// whatever piece of data, it will never be used by sendee
|
||||
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_A(NR_RRC, "Sent initial NRUE Capability response to LTE UE\n");
|
||||
break;
|
||||
}
|
||||
|
||||
case NRUE_CAPABILITY_ENQUIRY: {
|
||||
LOG_I(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,
|
||||
(void **)&nr_freq_band_list,
|
||||
msg_buffer,
|
||||
msg_len);
|
||||
if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
|
||||
SEQUENCE_free(&asn_DEF_NR_FreqBandList, nr_freq_band_list, ASFM_FREE_EVERYTHING);
|
||||
LOG_E(NR_RRC, "Failed to decode UECapabilityInfo (%zu bits)\n", dec_rval.consumed);
|
||||
break;
|
||||
}
|
||||
LOG_I(NR_RRC, "Calling nsa_rrc_ue_process_ueCapabilityEnquiry\n");
|
||||
nsa_rrc_ue_process_ueCapabilityEnquiry(rrc);
|
||||
break;
|
||||
}
|
||||
|
||||
case RRC_MEASUREMENT_PROCEDURE: {
|
||||
LOG_I(NR_RRC, "We are processing a %d message \n", msg_type);
|
||||
|
||||
LTE_MeasObjectToAddMod_t *nr_meas_obj = NULL;
|
||||
asn_dec_rval_t dec_rval = uper_decode_complete(NULL,
|
||||
&asn_DEF_NR_MeasObjectToAddMod,
|
||||
(void **)&nr_meas_obj,
|
||||
msg_buffer,
|
||||
msg_len);
|
||||
if ((dec_rval.code != RC_OK) && (dec_rval.consumed == 0)) {
|
||||
SEQUENCE_free(&asn_DEF_NR_MeasObjectToAddMod, nr_meas_obj, ASFM_FREE_EVERYTHING);
|
||||
LOG_E(RRC, "Failed to decode measurement object (%zu bits) %d\n", dec_rval.consumed, dec_rval.code);
|
||||
break;
|
||||
}
|
||||
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();
|
||||
break;
|
||||
}
|
||||
|
||||
case RRC_CONFIG_COMPLETE_REQ: {
|
||||
struct msg {
|
||||
uint32_t RadioBearer_size;
|
||||
uint32_t SecondaryCellGroup_size;
|
||||
uint8_t trans_id;
|
||||
uint8_t padding[3];
|
||||
uint8_t buffer[];
|
||||
} hdr;
|
||||
AssertFatal(msg_len >= sizeof(hdr), "Bad received msg\n");
|
||||
memcpy(&hdr, msg_buffer, sizeof(hdr));
|
||||
LOG_I(NR_RRC, "We got an RRC_CONFIG_COMPLETE_REQ\n");
|
||||
uint32_t nr_RadioBearer_size = hdr.RadioBearer_size;
|
||||
uint32_t nr_SecondaryCellGroup_size = hdr.SecondaryCellGroup_size;
|
||||
AssertFatal(sizeof(hdr) + nr_RadioBearer_size + nr_SecondaryCellGroup_size <= msg_len,
|
||||
"nr_RadioBearerConfig1_r15 size %u nr_SecondaryCellGroupConfig_r15 size %u sizeof(hdr) %zu, msg_len = %d\n",
|
||||
nr_RadioBearer_size,
|
||||
nr_SecondaryCellGroup_size,
|
||||
sizeof(hdr),
|
||||
msg_len);
|
||||
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 %ld\n",
|
||||
nr_RadioBearer_size,
|
||||
nr_SecondaryCellGroup_size,
|
||||
t_id);
|
||||
|
||||
uint8_t *nr_RadioBearer_buffer = msg_buffer + offsetof(struct msg, buffer);
|
||||
uint8_t *nr_SecondaryCellGroup_buffer = nr_RadioBearer_buffer + nr_RadioBearer_size;
|
||||
process_nsa_message(get_NR_UE_rrc_inst(0), nr_SecondaryCellGroupConfig_r15, nr_SecondaryCellGroup_buffer, nr_SecondaryCellGroup_size);
|
||||
process_nsa_message(get_NR_UE_rrc_inst(0), nr_RadioBearerConfigX_r15, nr_RadioBearer_buffer, nr_RadioBearer_size);
|
||||
LOG_I(NR_RRC, "Calling do_NR_RRCReconfigurationComplete. t_id %ld \n", t_id);
|
||||
uint8_t buffer[NR_RRC_BUF_SIZE];
|
||||
size_t size = do_NR_RRCReconfigurationComplete_for_nsa(buffer, sizeof(buffer), t_id);
|
||||
nsa_sendmsg_to_lte_ue(buffer, size, NR_RRC_CONFIG_COMPLETE_REQ);
|
||||
break;
|
||||
}
|
||||
|
||||
case OAI_TUN_IFACE_NSA: {
|
||||
LOG_I(NR_RRC, "We got an OAI_TUN_IFACE_NSA!!\n");
|
||||
char cmd_line[NR_RRC_BUF_SIZE];
|
||||
memcpy(cmd_line, msg_buffer, sizeof(cmd_line));
|
||||
LOG_D(NR_RRC, "Command line: %s\n", cmd_line);
|
||||
if (background_system(cmd_line) != 0)
|
||||
LOG_E(NR_RRC, "ESM-PROC - failed command '%s'", cmd_line);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
LOG_E(NR_RRC, "No NSA Message Found\n");
|
||||
}
|
||||
}
|
||||
|
||||
void handle_RRCRelease(NR_UE_RRC_INST_t *rrc)
|
||||
{
|
||||
NR_UE_Timers_Constants_t *tac = &rrc->timers_and_constants;
|
||||
|
||||
@@ -1,85 +0,0 @@
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include "common/utils/LOG/log.h"
|
||||
#include "openair2/RRC/NR_UE/rrc_proto.h"
|
||||
|
||||
static const char nsa_ipaddr[] = "127.0.0.1";
|
||||
static int from_lte_ue_fd = -1;
|
||||
static int to_lte_ue_fd = -1;
|
||||
uint16_t ue_id_g;
|
||||
|
||||
int get_from_lte_ue_fd()
|
||||
{
|
||||
return from_lte_ue_fd;
|
||||
}
|
||||
|
||||
void nsa_sendmsg_to_lte_ue(const void *message, size_t msg_len, Rrc_Msg_Type_t msg_type)
|
||||
{
|
||||
LOG_I(NR_RRC, "Entered %s \n", __FUNCTION__);
|
||||
nsa_msg_t n_msg;
|
||||
if (msg_len > sizeof(n_msg.msg_buffer))
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: message too big: %zu\n", __func__, msg_len);
|
||||
abort();
|
||||
}
|
||||
n_msg.msg_type = msg_type;
|
||||
memcpy(n_msg.msg_buffer, message, msg_len);
|
||||
size_t to_send = sizeof(n_msg.msg_type) + msg_len;
|
||||
|
||||
struct sockaddr_in sa =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons(6007 + ue_id_g * 2),
|
||||
};
|
||||
int sent = sendto(from_lte_ue_fd, &n_msg, to_send, 0,
|
||||
(struct sockaddr *)&sa, sizeof(sa));
|
||||
if (sent == -1)
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: sendto: %s\n", __func__, strerror(errno));
|
||||
return;
|
||||
}
|
||||
if (sent != to_send)
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: Short send %d != %zu\n", __func__, sent, to_send);
|
||||
return;
|
||||
}
|
||||
LOG_D(NR_RRC, "Sent a %d message to the LTE UE (%d bytes) \n", msg_type, sent);
|
||||
}
|
||||
|
||||
void init_connections_with_lte_ue(void)
|
||||
{
|
||||
struct sockaddr_in sa =
|
||||
{
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = htons(6008 + ue_id_g * 2),
|
||||
};
|
||||
AssertFatal(from_lte_ue_fd == -1, "from_lte_ue_fd %d was assigned already", from_lte_ue_fd);
|
||||
from_lte_ue_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (from_lte_ue_fd == -1)
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: Error opening socket %d (%d:%s)\n", __FUNCTION__, from_lte_ue_fd, errno, strerror(errno));
|
||||
abort();
|
||||
}
|
||||
|
||||
if (inet_aton(nsa_ipaddr, &sa.sin_addr) == 0)
|
||||
{
|
||||
LOG_E(NR_RRC, "Bad nsa_ipaddr '%s'\n", nsa_ipaddr);
|
||||
abort();
|
||||
}
|
||||
|
||||
if (bind(from_lte_ue_fd, (struct sockaddr *) &sa, sizeof(sa)) == -1)
|
||||
{
|
||||
LOG_E(NR_RRC,"%s: Failed to bind the socket\n", __FUNCTION__);
|
||||
abort();
|
||||
}
|
||||
|
||||
AssertFatal(to_lte_ue_fd == -1, "to_lte_ue_fd was assigned already");
|
||||
to_lte_ue_fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
if (to_lte_ue_fd == -1)
|
||||
{
|
||||
LOG_E(NR_RRC, "%s: Error opening socket %d (%d:%s)\n", __FUNCTION__, to_lte_ue_fd, errno, strerror(errno));
|
||||
abort();
|
||||
}
|
||||
LOG_I(NR_RRC, "Started LTE-NR link in the nr-UE\n");
|
||||
}
|
||||
@@ -68,14 +68,6 @@ void nr_rrc_handle_timers(NR_UE_RRC_INST_t *rrc);
|
||||
void handle_rlf_detection(NR_UE_RRC_INST_t *rrc);
|
||||
void handle_302_expired_stopped(NR_UE_RRC_INST_t *rrc);
|
||||
|
||||
/**\brief RRC NSA UE task.
|
||||
\param void *args_p Pointer on arguments to start the task. */
|
||||
void *recv_msgs_from_lte_ue(void *args_p);
|
||||
|
||||
void init_connections_with_lte_ue(void);
|
||||
|
||||
extern void start_oai_nrue_threads(void);
|
||||
|
||||
int get_from_lte_ue_fd();
|
||||
|
||||
void nr_rrc_SI_timers(NR_UE_RRC_SI_INFO *SInfo);
|
||||
|
||||
Reference in New Issue
Block a user