/* * Copyright 2013-2019 Software Radio Systems Limited * * This file is part of srsLTE. * * srsLTE is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as * published by the Free Software Foundation, either version 3 of * the License, or (at your option) any later version. * * srsLTE is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Affero General Public License for more details. * * A copy of the GNU Affero General Public License can be found in * the LICENSE file in the top-level directory of this distribution * and at http://www.gnu.org/licenses/. * */ /****************************************************************************** * File: interfaces.h * Description: Abstract base class interfaces provided by layers * to other layers. *****************************************************************************/ #ifndef SRSLTE_UE_INTERFACES_H #define SRSLTE_UE_INTERFACES_H #include #include "srslte/asn1/liblte_mme.h" #include "srslte/asn1/rrc_asn1.h" #include "srslte/common/common.h" #include "srslte/common/interfaces_common.h" #include "srslte/common/security.h" #include "srslte/phy/rf/rf.h" #include "srslte/upper/rlc_interface.h" namespace srsue { typedef enum { AUTH_OK, AUTH_FAILED, AUTH_SYNCH_FAILURE } auth_result_t; // UE interface class ue_interface { }; // USIM interface for NAS class usim_interface_nas { public: virtual std::string get_imsi_str() = 0; virtual std::string get_imei_str() = 0; virtual bool get_imsi_vec(uint8_t* imsi_, uint32_t n) = 0; virtual bool get_imei_vec(uint8_t* imei_, uint32_t n) = 0; virtual bool get_home_plmn_id(asn1::rrc::plmn_id_s* home_plmn_id) = 0; virtual auth_result_t generate_authentication_response(uint8_t *rand, uint8_t *autn_enb, uint16_t mcc, uint16_t mnc, uint8_t *res, int *res_len, uint8_t *k_asme) = 0; virtual void generate_nas_keys(uint8_t *k_asme, uint8_t *k_nas_enc, uint8_t *k_nas_int, srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo, srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) = 0; }; // USIM interface for RRC class usim_interface_rrc { public: virtual void generate_as_keys(uint8_t *k_asme, uint32_t count_ul, uint8_t *k_rrc_enc, uint8_t *k_rrc_int, uint8_t *k_up_enc, uint8_t *k_up_int, srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo, srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) = 0; virtual void generate_as_keys_ho(uint32_t pci, uint32_t earfcn, int ncc, uint8_t *k_rrc_enc, uint8_t *k_rrc_int, uint8_t *k_up_enc, uint8_t *k_up_int, srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo, srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo) = 0; }; // GW interface for NAS class gw_interface_nas { public: virtual srslte::error_t setup_if_addr(uint8_t pdn_type, uint32_t ip_addr, uint8_t *ipv6_if_id, char *err_str) = 0; }; // GW interface for RRC class gw_interface_rrc { public: virtual void add_mch_port(uint32_t lcid, uint32_t port) = 0; }; // GW interface for PDCP class gw_interface_pdcp { public: virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; }; // NAS interface for RRC class nas_interface_rrc { public: typedef enum { BARRING_NONE = 0, BARRING_MO_DATA, BARRING_MO_SIGNALLING, BARRING_MT, BARRING_ALL } barring_t; virtual void set_barring(barring_t barring) = 0; virtual void paging(asn1::rrc::s_tmsi_s* ue_identiy) = 0; virtual bool is_attached() = 0; virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; virtual uint32_t get_k_enb_count() = 0; virtual bool get_k_asme(uint8_t *k_asme_, uint32_t n) = 0; virtual uint32_t get_ipv4_addr() = 0; virtual bool get_ipv6_addr(uint8_t *ipv6_addr) = 0; }; // NAS interface for UE class nas_interface_ue { public: virtual bool attach_request() = 0; virtual bool detach_request() = 0; }; // NAS interface for UE class nas_interface_gw { public: virtual bool attach_request() = 0; }; // RRC interface for MAC class rrc_interface_mac_common { public: virtual void ra_problem() = 0; }; class rrc_interface_mac : public rrc_interface_mac_common { public: virtual void ho_ra_completed(bool ra_successful) = 0; virtual void release_pucch_srs() = 0; virtual void run_tti(uint32_t tti) = 0; }; // RRC interface for PHY class rrc_interface_phy_lte { public: virtual void in_sync() = 0; virtual void out_of_sync() = 0; virtual void new_phy_meas(float rsrp, float rsrq, uint32_t tti, int earfcn = -1, int pci = -1) = 0; }; // RRC interface for NAS class rrc_interface_nas { public: typedef struct { asn1::rrc::plmn_id_s plmn_id; uint16_t tac; } found_plmn_t; const static int MAX_FOUND_PLMNS = 16; virtual void write_sdu(srslte::unique_byte_buffer_t sdu) = 0; virtual uint16_t get_mcc() = 0; virtual uint16_t get_mnc() = 0; virtual void enable_capabilities() = 0; virtual int plmn_search(found_plmn_t found_plmns[MAX_FOUND_PLMNS]) = 0; virtual void plmn_select(asn1::rrc::plmn_id_s plmn_id) = 0; virtual bool connection_request(asn1::rrc::establishment_cause_e cause, srslte::unique_byte_buffer_t dedicatedInfoNAS) = 0; virtual void set_ue_idenity(asn1::rrc::s_tmsi_s s_tmsi) = 0; virtual bool is_connected() = 0; virtual std::string get_rb_name(uint32_t lcid) = 0; }; // RRC interface for PDCP class rrc_interface_pdcp { public: virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu_bcch_bch(srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu_pcch(srslte::unique_byte_buffer_t pdu) = 0; virtual void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; virtual std::string get_rb_name(uint32_t lcid) = 0; }; // RRC interface for RLC class rrc_interface_rlc { public: virtual void max_retx_attempted() = 0; virtual std::string get_rb_name(uint32_t lcid) = 0; }; // PDCP interface for GW class pdcp_interface_gw { public: virtual void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking) = 0; virtual bool is_lcid_enabled(uint32_t lcid) = 0; }; // PDCP interface for RRC class pdcp_interface_rrc { public: virtual void reestablish() = 0; virtual void reset() = 0; virtual void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking = true) = 0; virtual void add_bearer(uint32_t lcid, srslte::srslte_pdcp_config_t cnfg = srslte::srslte_pdcp_config_t()) = 0; virtual void change_lcid(uint32_t old_lcid, uint32_t new_lcid) = 0; virtual void config_security(uint32_t lcid, uint8_t *k_rrc_enc_, uint8_t *k_rrc_int_, uint8_t *k_up_enc_, srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo_, srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo_) = 0; virtual void config_security_all(uint8_t *k_rrc_enc_, uint8_t *k_rrc_int_, uint8_t *k_up_enc_, srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo_, srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo_) = 0; virtual void enable_integrity(uint32_t lcid) = 0; virtual void enable_encryption(uint32_t lcid) = 0; virtual uint32_t get_dl_count(uint32_t lcid) = 0; virtual uint32_t get_ul_count(uint32_t lcid) = 0; }; // PDCP interface for RLC class pdcp_interface_rlc { public: /* RLC calls PDCP to push a PDCP PDU. */ virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; virtual void write_pdu_bcch_bch(srslte::unique_byte_buffer_t sdu) = 0; virtual void write_pdu_bcch_dlsch(srslte::unique_byte_buffer_t sdu) = 0; virtual void write_pdu_pcch(srslte::unique_byte_buffer_t sdu) = 0; virtual void write_pdu_mch(uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; }; // RLC interface for RRC class rlc_interface_rrc { public: virtual void reset() = 0; virtual void reestablish() = 0; virtual void reestablish(uint32_t lcid) = 0; virtual void add_bearer(uint32_t lcid) = 0; virtual void add_bearer(uint32_t lcid, srslte::srslte_rlc_config_t cnfg) = 0; virtual void add_bearer_mrb(uint32_t lcid) = 0; virtual void del_bearer(uint32_t lcid) = 0; virtual void change_lcid(uint32_t old_lcid, uint32_t new_lcid) = 0; virtual bool has_bearer(uint32_t lcid) = 0; virtual bool has_data(const uint32_t lcid) = 0; }; // RLC interface for PDCP class rlc_interface_pdcp { public: /* PDCP calls RLC to push an RLC SDU. SDU gets placed into the RLC buffer and MAC pulls * RLC PDUs according to TB size. */ virtual void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking = true) = 0; virtual bool rb_is_um(uint32_t lcid) = 0; }; //RLC interface for MAC class rlc_interface_mac : public srslte::read_pdu_interface { public: /* MAC calls has_data() to query whether a logical channel has data to transmit (without * knowing how much. This function should return quickly. */ virtual bool has_data(const uint32_t lcid) = 0; /* MAC calls RLC to get the buffer state for a logical channel. */ virtual uint32_t get_buffer_state(const uint32_t lcid) = 0; const static int MAX_PDU_SEGMENTS = 20; /* MAC calls RLC to get RLC segment of nof_bytes length. * Segmentation happens in this function. RLC PDU is stored in payload. */ virtual int read_pdu(uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0; /* MAC calls RLC to push an RLC PDU. This function is called from an independent MAC thread. * PDU gets placed into the buffer and higher layer thread gets notified. */ virtual void write_pdu(uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0; virtual void write_pdu_bcch_bch(uint8_t *payload, uint32_t nof_bytes) = 0; virtual void write_pdu_bcch_dlsch(uint8_t *payload, uint32_t nof_bytes) = 0; virtual void write_pdu_pcch(uint8_t *payload, uint32_t nof_bytes) = 0; virtual void write_pdu_mch(uint32_t lcid, uint8_t *payload, uint32_t nof_bytes) = 0; }; //BSR interface for MUX class bsr_interface_mux { public: typedef enum { LONG_BSR, SHORT_BSR, TRUNC_BSR } bsr_format_t; typedef struct { bsr_format_t format; uint32_t buff_size[4]; } bsr_t; /* MUX calls BSR to check if it can fit a BSR into PDU */ virtual bool need_to_send_bsr_on_ul_grant(uint32_t grant_size, bsr_t *bsr) = 0; /* MUX calls BSR to let it generate a padding BSR if there is space in PDU */ virtual bool generate_padding_bsr(uint32_t nof_padding_bytes, bsr_t *bsr) = 0; }; /** MAC interface * */ /* Interface PHY -> MAC */ class mac_interface_phy_lte { public: typedef struct { uint32_t nof_mbsfn_services; } mac_phy_cfg_mbsfn_t; typedef struct { uint32_t tbs; bool ndi; bool ndi_present; int rv; } mac_tb_t; typedef struct { mac_tb_t tb[SRSLTE_MAX_TB]; uint32_t pid; uint16_t rnti; bool is_sps_release; } mac_grant_dl_t; typedef struct { mac_tb_t tb; uint32_t pid; uint16_t rnti; bool phich_available; bool hi_value; } mac_grant_ul_t; typedef struct { bool enabled; uint32_t rv; uint8_t* payload; union { srslte_softbuffer_rx_t* rx; srslte_softbuffer_tx_t* tx; } softbuffer; } tb_action_t; typedef struct { tb_action_t tb[SRSLTE_MAX_TB]; bool generate_ack; } tb_action_dl_t; typedef struct { tb_action_t tb; uint32_t current_tx_nb; bool expect_ack; } tb_action_ul_t; /* Query the MAC for the current RNTI to look for */ virtual uint16_t get_dl_sched_rnti(uint32_t tti) = 0; virtual uint16_t get_ul_sched_rnti(uint32_t tti) = 0; /* Indicate reception of UL dci. * payload_ptr points to memory where MAC PDU must be written by MAC layer */ virtual void new_grant_ul(uint32_t cc_idx, mac_grant_ul_t grant, tb_action_ul_t* action) = 0; /* Indicate reception of DL dci. */ virtual void new_grant_dl(uint32_t cc_idx, mac_grant_dl_t grant, tb_action_dl_t* action) = 0; /* Indicate successful decoding of PDSCH AND PCH TB. */ virtual void tb_decoded(uint32_t cc_idx, mac_grant_dl_t grant, bool ack[SRSLTE_MAX_CODEWORDS]) = 0; /* Indicate successful decoding of BCH TB through PBCH */ virtual void bch_decoded_ok(uint8_t* payload, uint32_t len) = 0; /* Indicate successful decoding of MCH TB through PMCH */ virtual void mch_decoded(uint32_t len, bool crc) = 0; /* Obtain action for a new MCH subframe. */ virtual void new_mch_dl(srslte_pdsch_grant_t phy_grant, tb_action_dl_t* action) = 0; /* Communicate the number of mbsfn services available */ virtual void set_mbsfn_config(uint32_t nof_mbsfn_services) = 0; /* Indicate new TTI */ virtual void run_tti(const uint32_t tti) = 0; }; /* Interface RRC -> MAC shared between different RATs */ class mac_interface_rrc_common { public: // Class to handle UE specific RNTIs between RRC and MAC typedef struct { uint16_t crnti; uint16_t rar_rnti; uint16_t temp_rnti; uint16_t tpc_rnti; uint16_t sps_rnti; uint64_t contention_id; } ue_rnti_t; typedef struct ul_harq_cfg_t { uint32_t max_harq_msg3_tx; uint32_t max_harq_tx; ul_harq_cfg_t() { reset(); } void reset() { max_harq_msg3_tx = 5; max_harq_tx = 5; } } ul_harq_cfg_t; }; /* Interface RRC -> MAC */ class mac_interface_rrc : public mac_interface_rrc_common { public: typedef struct bsr_cfg_t { int periodic_timer; int retx_timer; bsr_cfg_t() { reset(); } void reset() { periodic_timer = -1; retx_timer = 2560; } } bsr_cfg_t; typedef struct phr_cfg_t { bool enabled; int periodic_timer; int prohibit_timer; int db_pathloss_change; bool extended; phr_cfg_t() { reset(); } void reset() { enabled = false; periodic_timer = -1; prohibit_timer = -1; db_pathloss_change = -1; extended = false; } } phr_cfg_t; typedef struct sr_cfg_t { bool enabled; int dsr_transmax; sr_cfg_t() { reset(); } void reset() { enabled = false; dsr_transmax = 0; } } sr_cfg_t; typedef struct rach_cfg_t { bool enabled; uint32_t nof_preambles; uint32_t nof_groupA_preambles; int32_t messagePowerOffsetGroupB; uint32_t messageSizeGroupA; uint32_t responseWindowSize; uint32_t powerRampingStep; uint32_t preambleTransMax; int32_t iniReceivedTargetPower; uint32_t contentionResolutionTimer; uint32_t new_ra_msg_len; rach_cfg_t() { reset(); } void reset() { enabled = false; nof_preambles = 0; nof_groupA_preambles = 0; messagePowerOffsetGroupB = 0; messageSizeGroupA = 0; responseWindowSize = 0; powerRampingStep = 0; preambleTransMax = 0; iniReceivedTargetPower = 0; contentionResolutionTimer = 0; new_ra_msg_len = 0; } } rach_cfg_t; class mac_cfg_t { public: // Default constructor with default values as in 36.331 9.2.2 mac_cfg_t() { set_defaults(); } void set_defaults() { rach_cfg.reset(); set_mac_main_cfg_default(); } void set_mac_main_cfg_default() { bsr_cfg.reset(); phr_cfg.reset(); sr_cfg.reset(); harq_cfg.reset(); time_alignment_timer = -1; } // Called only if section is present void set_sched_request_cfg(asn1::rrc::sched_request_cfg_c& cfg) { sr_cfg.enabled = cfg.type() == asn1::rrc::setup_e::setup; if (sr_cfg.enabled) { sr_cfg.dsr_transmax = cfg.setup().dsr_trans_max.to_number(); } } // MAC-MainConfig section is always present void set_mac_main_cfg(asn1::rrc::mac_main_cfg_s& cfg) { // Update values only if each section is present if (cfg.phr_cfg_present) { phr_cfg.enabled = cfg.phr_cfg.type() == asn1::rrc::setup_e::setup; if (phr_cfg.enabled) { phr_cfg.prohibit_timer = cfg.phr_cfg.setup().prohibit_phr_timer.to_number(); phr_cfg.periodic_timer = cfg.phr_cfg.setup().periodic_phr_timer.to_number(); phr_cfg.db_pathloss_change = cfg.phr_cfg.setup().dl_pathloss_change.to_number(); } } if (cfg.mac_main_cfg_v1020_present) { typedef asn1::rrc::mac_main_cfg_s::mac_main_cfg_v1020_s_ mac_main_cfg_v1020_t; mac_main_cfg_v1020_t* mac_main_cfg_v1020 = cfg.mac_main_cfg_v1020.get(); phr_cfg.extended = mac_main_cfg_v1020->extended_phr_r10_present; } if (cfg.ul_sch_cfg_present) { bsr_cfg.periodic_timer = cfg.ul_sch_cfg.periodic_bsr_timer.to_number(); bsr_cfg.retx_timer = cfg.ul_sch_cfg.retx_bsr_timer.to_number(); if (cfg.ul_sch_cfg.max_harq_tx_present) { harq_cfg.max_harq_tx = cfg.ul_sch_cfg.max_harq_tx.to_number(); } } // TimeAlignmentDedicated overwrites Common?? time_alignment_timer = cfg.time_align_timer_ded.to_number(); } // RACH-Common section is always present void set_rach_cfg_common(asn1::rrc::rach_cfg_common_s& cfg) { // Preamble info rach_cfg.nof_preambles = cfg.preamb_info.nof_ra_preambs.to_number(); if (cfg.preamb_info.preambs_group_a_cfg_present) { rach_cfg.nof_groupA_preambles = cfg.preamb_info.preambs_group_a_cfg.size_of_ra_preambs_group_a.to_number(); rach_cfg.messageSizeGroupA = cfg.preamb_info.preambs_group_a_cfg.msg_size_group_a.to_number(); rach_cfg.messagePowerOffsetGroupB = cfg.preamb_info.preambs_group_a_cfg.msg_pwr_offset_group_b.to_number(); } else { rach_cfg.nof_groupA_preambles = 0; } // Power ramping rach_cfg.powerRampingStep = cfg.pwr_ramp_params.pwr_ramp_step.to_number(); rach_cfg.iniReceivedTargetPower = cfg.pwr_ramp_params.preamb_init_rx_target_pwr.to_number(); // Supervision info rach_cfg.preambleTransMax = cfg.ra_supervision_info.preamb_trans_max.to_number(); rach_cfg.responseWindowSize = cfg.ra_supervision_info.ra_resp_win_size.to_number(); rach_cfg.contentionResolutionTimer = cfg.ra_supervision_info.mac_contention_resolution_timer.to_number(); // HARQ Msg3 harq_cfg.max_harq_msg3_tx = cfg.max_harq_msg3_tx; } void set_time_alignment(asn1::rrc::time_align_timer_e time_alignment_timer) { this->time_alignment_timer = time_alignment_timer.to_number(); } bsr_cfg_t& get_bsr_cfg() { return bsr_cfg; } phr_cfg_t& get_phr_cfg() { return phr_cfg; } rach_cfg_t& get_rach_cfg() { return rach_cfg; } sr_cfg_t& get_sr_cfg() { return sr_cfg; } ul_harq_cfg_t& get_harq_cfg() { return harq_cfg; } int get_time_alignment_timer() { return time_alignment_timer; } private: bsr_cfg_t bsr_cfg; phr_cfg_t phr_cfg; sr_cfg_t sr_cfg; rach_cfg_t rach_cfg; ul_harq_cfg_t harq_cfg; int time_alignment_timer; }; virtual void clear_rntis() = 0; /* Instructs the MAC to start receiving BCCH */ virtual void bcch_start_rx(int si_window_start, int si_window_length) = 0; virtual void bcch_stop_rx() = 0; /* Instructs the MAC to start receiving PCCH */ virtual void pcch_start_rx() = 0; /* RRC configures a logical channel */ virtual void setup_lcid(uint32_t lcid, uint32_t lcg, uint32_t priority, int PBR_x_tti, uint32_t BSD) = 0; /* Instructs the MAC to start receiving an MCH */ virtual void mch_start_rx(uint32_t lcid) = 0; virtual uint32_t get_current_tti() = 0; virtual void set_config(mac_cfg_t& mac_cfg) = 0; virtual void get_rntis(ue_rnti_t *rntis) = 0; virtual void set_contention_id(uint64_t uecri) = 0; virtual void set_ho_rnti(uint16_t crnti, uint16_t target_pci) = 0; virtual void start_noncont_ho(uint32_t preamble_index, uint32_t prach_mask) = 0; virtual void start_cont_ho() = 0; virtual void reconfiguration(const uint32_t& cc_idx, const bool& enable) = 0; virtual void reset() = 0; virtual void wait_uplink() = 0; }; // RF/radio args typedef struct { std::string type; std::string log_level; float freq_offset; float rx_gain; float tx_gain; float tx_max_power; float tx_gain_offset; float rx_gain_offset; uint32_t nof_radios; uint32_t nof_rf_channels; // Number of RF channels per radio uint32_t nof_rx_ant; // Number of RF channels for MIMO std::string device_name; std::string device_args[SRSLTE_MAX_RADIOS]; std::string time_adv_nsamples; std::string burst_preamble; std::string continuous_tx; } rf_args_t; /** PHY interface * */ typedef struct { uint32_t radio_idx; uint32_t channel_idx; } carrier_map_t; typedef struct { std::string phy_level; std::string phy_lib_level; int phy_hex_limit; } phy_log_args_t; typedef struct { std::string type; phy_log_args_t log; std::string dl_earfcn; // comma-separated list of EARFCNs std::vector earfcn_list; // vectorized version of dl_earfcn that gets populated during init float dl_freq; float ul_freq; bool ul_pwr_ctrl_en; float prach_gain; int pdsch_max_its; bool attach_enable_64qam; int nof_phy_threads; int worker_cpu_mask; int sync_cpu_affinity; uint32_t ue_category; uint32_t nof_carriers; uint32_t nof_radios; uint32_t nof_rx_ant; uint32_t nof_rf_channels; carrier_map_t carrier_map[SRSLTE_MAX_CARRIERS]; std::string equalizer_mode; int cqi_max; int cqi_fixed; float snr_ema_coeff; std::string snr_estim_alg; bool cfo_is_doppler; bool cfo_integer_enabled; float cfo_correct_tol_hz; float cfo_pss_ema; float cfo_ref_ema; float cfo_loop_bw_pss; float cfo_loop_bw_ref; float cfo_loop_ref_min; float cfo_loop_pss_tol; float sfo_ema; uint32_t sfo_correct_period; uint32_t cfo_loop_pss_conv; uint32_t cfo_ref_mask; bool interpolate_subframe_enabled; bool estimator_fil_auto; float estimator_fil_stddev; uint32_t estimator_fil_order; float snr_to_cqi_offset; std::string sss_algorithm; bool sic_pss_enabled; float rx_gain_offset; bool pdsch_csi_enabled; bool pdsch_8bit_decoder; uint32_t intra_freq_meas_len_ms; uint32_t intra_freq_meas_period_ms; bool pregenerate_signals; } phy_args_t; /* RAT agnostic Interface MAC -> PHY */ class phy_interface_mac_common { public: /* Sets a C-RNTI allowing the PHY to pregenerate signals if necessary */ virtual void set_crnti(uint16_t rnti) = 0; /* Time advance commands */ virtual void set_timeadv_rar(uint32_t ta_cmd) = 0; virtual void set_timeadv(uint32_t ta_cmd) = 0; /* Activate / Disactivate SCell*/ virtual void set_activation_deactivation_scell(uint32_t cmd) = 0; /* Sets RAR dci payload */ virtual void set_rar_grant(uint8_t grant_payload[SRSLTE_RAR_GRANT_LEN], uint16_t rnti) = 0; virtual uint32_t get_current_tti() = 0; virtual float get_phr() = 0; virtual float get_pathloss_db() = 0; }; /* Interface MAC -> PHY */ class phy_interface_mac_lte : public phy_interface_mac_common { public: typedef struct { bool is_transmitted; uint32_t tti_ra; uint32_t f_id; uint32_t preamble_format; } prach_info_t; /* Configure PRACH using parameters written by RRC */ virtual void configure_prach_params() = 0; virtual void prach_send(uint32_t preamble_idx, int allowed_subframe, float target_power_dbm) = 0; virtual prach_info_t prach_get_info() = 0; /* Indicates the transmission of a SR signal in the next opportunity */ virtual void sr_send() = 0; virtual int sr_last_tx_tti() = 0; virtual void set_mch_period_stop(uint32_t stop) = 0; }; class phy_interface_rrc_lte { public: struct phy_cfg_common_t { asn1::rrc::prach_cfg_sib_s prach_cnfg; asn1::rrc::pdsch_cfg_common_s pdsch_cnfg; asn1::rrc::pusch_cfg_common_s pusch_cnfg; asn1::rrc::phich_cfg_s phich_cnfg; asn1::rrc::pucch_cfg_common_s pucch_cnfg; asn1::rrc::srs_ul_cfg_common_c srs_ul_cnfg; asn1::rrc::ul_pwr_ctrl_common_s ul_pwr_ctrl; asn1::rrc::tdd_cfg_s tdd_cnfg; asn1::rrc::srs_ant_port_e ant_info; }; struct phy_cfg_mbsfn_t { asn1::rrc::mbsfn_sf_cfg_s mbsfn_subfr_cnfg; asn1::rrc::mbms_notif_cfg_r9_s mbsfn_notification_cnfg; asn1::rrc::mbsfn_area_info_r9_s mbsfn_area_info; asn1::rrc::mcch_msg_s mcch; }; typedef struct { asn1::rrc::phys_cfg_ded_s dedicated; phy_cfg_common_t common; phy_cfg_mbsfn_t mbsfn; } phy_cfg_t; virtual void get_current_cell(srslte_cell_t *cell, uint32_t *current_earfcn = NULL) = 0; virtual uint32_t get_current_earfcn() = 0; virtual uint32_t get_current_pci() = 0; virtual void set_config(phy_cfg_t* config) = 0; virtual void set_config_scell(asn1::rrc::scell_to_add_mod_r10_s* scell_config) = 0; virtual void set_config_tdd(asn1::rrc::tdd_cfg_s* tdd) = 0; virtual void set_config_mbsfn_sib2(asn1::rrc::sib_type2_s* sib2) = 0; virtual void set_config_mbsfn_sib13(asn1::rrc::sib_type13_r9_s* sib13) = 0; virtual void set_config_mbsfn_mcch(asn1::rrc::mcch_msg_s* mcch) = 0; /* Measurements interface */ virtual void meas_reset() = 0; virtual int meas_start(uint32_t earfcn, int pci = -1) = 0; virtual int meas_stop(uint32_t earfcn, int pci = -1) = 0; typedef struct { enum {CELL_FOUND = 0, CELL_NOT_FOUND, ERROR} found; enum { MORE_FREQS = 0, NO_MORE_FREQS } last_freq; } cell_search_ret_t; typedef struct { srslte_cell_t cell; uint32_t earfcn; } phy_cell_t; /* Cell search and selection procedures */ virtual cell_search_ret_t cell_search(phy_cell_t *cell) = 0; virtual bool cell_select(phy_cell_t *cell = NULL) = 0; virtual bool cell_is_camping() = 0; virtual void reset() = 0; virtual void enable_pregen_signals(bool enable) = 0; }; class radio_interface_phy { public: // trx functions virtual bool tx(const uint32_t& radio_idx, cf_t* buffer[SRSLTE_MAX_PORTS], const uint32_t& nof_samples, const srslte_timestamp_t& tx_time) = 0; virtual void tx_end() = 0; virtual bool rx_now(const uint32_t& radio_idx, cf_t* buffer[SRSLTE_MAX_PORTS], const uint32_t& nof_samples, srslte_timestamp_t* rxd_time) = 0; // setter virtual void set_tx_freq(const uint32_t& radio_idx, const uint32_t& channel_idx, const double& freq) = 0; virtual void set_rx_freq(const uint32_t& radio_idx, const uint32_t& channel_idx, const double& freq) = 0; virtual double set_rx_gain_th(const float& gain) = 0; virtual void set_rx_gain(const uint32_t& radio_idx, const float& gain) = 0; virtual void set_tx_srate(const uint32_t& radio_idx, const double& srate) = 0; virtual void set_rx_srate(const uint32_t& radio_idx, const double& srate) = 0; // getter virtual float get_rx_gain(const uint32_t& radio_idx) = 0; virtual double get_freq_offset() = 0; virtual double get_tx_freq(const uint32_t& radio_idx) = 0; virtual double get_rx_freq(const uint32_t& radio_idx) = 0; virtual float get_max_tx_power() = 0; virtual float get_tx_gain_offset() = 0; virtual float get_rx_gain_offset() = 0; virtual bool is_continuous_tx() = 0; virtual bool is_init() = 0; virtual void reset() = 0; virtual srslte_rf_info_t* get_info(const uint32_t& radio_idx) = 0; }; class phy_interface_radio { public: virtual void radio_overflow() = 0; virtual void radio_failure() = 0; }; // Combined interface for PHY to access stack (MAC and RRC) class stack_interface_phy_lte : public mac_interface_phy_lte, public rrc_interface_phy_lte { }; // Combined interface for stack (MAC and RRC) to access PHY class phy_interface_stack_lte : public phy_interface_mac_lte, public phy_interface_rrc_lte { }; } // namespace srsue #endif // SRSLTE_UE_INTERFACES_H