diff --git a/lib/include/srslte/asn1/rrc_asn1_utils.h b/lib/include/srslte/asn1/rrc_asn1_utils.h index 20b151d87..5e7f15a06 100644 --- a/lib/include/srslte/asn1/rrc_asn1_utils.h +++ b/lib/include/srslte/asn1/rrc_asn1_utils.h @@ -32,6 +32,10 @@ * Forward declarations ***********************/ namespace asn1 { + +template +class fixed_octstring; + namespace rrc { struct plmn_id_s; @@ -81,6 +85,8 @@ namespace srslte { plmn_id_t make_plmn_id_t(const asn1::rrc::plmn_id_s& asn1_type); void to_asn1(asn1::rrc::plmn_id_s* asn1_type, const plmn_id_t& cfg); +plmn_id_t make_plmn_id_t(const asn1::fixed_octstring<3, true>& asn1_type); +void to_asn1(asn1::fixed_octstring<3, true>* asn1_type, const plmn_id_t& cfg); s_tmsi_t make_s_tmsi_t(const asn1::rrc::s_tmsi_s& asn1_type); void to_asn1(asn1::rrc::s_tmsi_s* asn1_type, const s_tmsi_t& cfg); diff --git a/lib/include/srslte/common/interfaces_common.h b/lib/include/srslte/common/interfaces_common.h index 5afd183d0..8e481c38f 100644 --- a/lib/include/srslte/common/interfaces_common.h +++ b/lib/include/srslte/common/interfaces_common.h @@ -90,6 +90,9 @@ public: virtual void notify_background_task_result(srslte::move_task_t task) = 0; }; +class stack_interface_phy_nr +{}; + } // namespace srslte #endif // SRSLTE_INTERFACES_COMMON_H diff --git a/lib/include/srslte/common/log_filter.h b/lib/include/srslte/common/log_filter.h index e8b9cb31d..ccf1dd637 100644 --- a/lib/include/srslte/common/log_filter.h +++ b/lib/include/srslte/common/log_filter.h @@ -64,8 +64,6 @@ public: void info_hex(const uint8_t* hex, int size, const char* message, ...) __attribute__((format(printf, 4, 5))); void debug_hex(const uint8_t* hex, int size, const char* message, ...) __attribute__((format(printf, 4, 5))); - srslte::LOG_LEVEL_ENUM get_level(std::string l); - class time_itf { public: diff --git a/lib/include/srslte/interfaces/gnb_interfaces.h b/lib/include/srslte/interfaces/gnb_interfaces.h new file mode 100644 index 000000000..41f9a1d52 --- /dev/null +++ b/lib/include/srslte/interfaces/gnb_interfaces.h @@ -0,0 +1,225 @@ +/* + * 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/. + * + */ + +#ifndef SRSLTE_GNB_INTERFACES_H +#define SRSLTE_GNB_INTERFACES_H + +#include "srslte/common/interfaces_common.h" +#include "srslte/common/security.h" +#include "srslte/interfaces/pdcp_interface_types.h" +#include "srslte/interfaces/rlc_interface_types.h" +#include "srslte/interfaces/rrc_interface_types.h" +#include "srslte/interfaces/sched_interface.h" + +namespace srsenb { + +/***************************** + * MAC INTERFACES + ****************************/ +class mac_interface_rrc_nr +{ +public: + // Provides cell configuration including SIB periodicity, etc. + virtual int cell_cfg(srsenb::sched_interface::cell_cfg_t* cell_cfg) = 0; +}; + +class mac_interface_rlc_nr +{ +public: + virtual int rlc_buffer_state(uint16_t rnti, uint32_t lc_id, uint32_t tx_queue, uint32_t retx_queue) = 0; +}; + +/***************************** + * RLC INTERFACES + ****************************/ +class rlc_interface_mac_nr +{ +public: + /* 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(uint16_t rnti, uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) = 0; + virtual void read_pdu_pcch(uint8_t* payload, uint32_t buffer_size) = 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(uint16_t rnti, uint32_t lcid, uint8_t* payload, uint32_t nof_bytes) = 0; +}; +class rlc_interface_pdcp_nr +{ +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(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; + virtual bool rb_is_um(uint16_t rnti, uint32_t lcid) = 0; +}; +class rlc_interface_rrc_nr +{ +public: + virtual void clear_buffer(uint16_t rnti) = 0; + virtual void add_user(uint16_t rnti) = 0; + virtual void rem_user(uint16_t rnti) = 0; + virtual void add_bearer(uint16_t rnti, uint32_t lcid, srslte::rlc_config_t cnfg) = 0; + virtual void add_bearer_mrb(uint16_t rnti, uint32_t lcid) = 0; + virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; +}; + +/* PDCP Interfaces */ +class pdcp_interface_rlc_nr +{ +public: + /* RLC calls PDCP to push a PDCP PDU. */ + virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; +}; +class pdcp_interface_rrc_nr +{ +public: + virtual void reset(uint16_t rnti) = 0; + virtual void add_user(uint16_t rnti) = 0; + virtual void rem_user(uint16_t rnti) = 0; + virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; + virtual void add_bearer(uint16_t rnti, uint32_t lcid, srslte::pdcp_config_t cnfg) = 0; + virtual void config_security(uint16_t rnti, uint32_t lcid, srslte::as_security_config_t sec_cfg) = 0; + virtual void enable_integrity(uint16_t rnti, uint32_t lcid) = 0; + virtual void enable_encryption(uint16_t rnti, uint32_t lcid) = 0; +}; +class pdcp_interface_sdap_nr +{ +public: + virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; +}; + +class s1ap_interface_rrc_nr +{}; +class gtpu_interface_sdap_nr +{ +public: + virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; +}; + +/***************************** + * SDAP INTERFACES + ****************************/ +class sdap_interface_pdcp_nr +{ +public: + virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; +}; +class sdap_interface_gtpu_nr +{ +public: + virtual void write_sdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; +}; + +/***************************** + * GTPU INTERFACES + ****************************/ +class gtpu_interface_rrc_nr +{ +public: +}; + +/***************************** + * RRC INTERFACES + ****************************/ +class rrc_interface_phy_nr +{}; +class rrc_interface_mac_nr +{ +public: + // Provides MIB packed message + virtual int read_pdu_bcch_bch(const uint32_t tti, srslte::unique_byte_buffer_t& buffer) = 0; + virtual int read_pdu_bcch_dlsch(uint32_t sib_index, srslte::unique_byte_buffer_t& buffer) = 0; +}; +class rrc_interface_rlc_nr +{ +public: + virtual void read_pdu_pcch(uint8_t* payload, uint32_t payload_size) = 0; + virtual void max_retx_attempted(uint16_t rnti) = 0; + virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t sdu) = 0; +}; +class rrc_interface_pdcp_nr +{ +public: + virtual void write_pdu(uint16_t rnti, uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0; +}; +class rrc_interface_ngap_nr +{ +public: +}; + +/***************************** + * NGAP INTERFACES + ****************************/ +class ngap_interface_rrc_nr +{ +public: +}; + +class phy_interface_stack_nr +{ +public: + const static int MAX_DL_GRANTS = 4; + + typedef struct { + // FIXME: not including NR related fields yet + } dl_sched_grant_t; + + typedef struct { + bool mib_present; + } bch_sched_t; + + typedef struct { + uint32_t tti; + uint32_t nof_grants; + dl_sched_grant_t pdsch[MAX_DL_GRANTS]; + int beam_id; + } dl_config_request_t; + + typedef struct { + bch_sched_t pbch; + uint16_t length; + uint16_t index; // index indicated in dl_config + uint8_t* data[SRSLTE_MAX_TB]; // always a pointer in our case + } tx_request_pdu_t; + + typedef struct { + uint32_t tti; + uint32_t tb_len; + uint32_t nof_pdus; + tx_request_pdu_t pdus[MAX_DL_GRANTS]; + } tx_request_t; + + virtual int dl_config_request(const dl_config_request_t& request) = 0; + virtual int tx_request(const tx_request_t& request) = 0; +}; + +class stack_interface_phy_nr : public srslte::stack_interface_phy_nr +{ +public: + virtual int sf_indication(const uint32_t tti) = 0; +}; + +class mac_interface_phy_nr +{}; + +} // namespace srsenb + +#endif // SRSLTE_GNB_INTERFACES_H diff --git a/lib/include/srslte/interfaces/pdcp_interface_types.h b/lib/include/srslte/interfaces/pdcp_interface_types.h index c843c7cc6..5b6dd9c72 100644 --- a/lib/include/srslte/interfaces/pdcp_interface_types.h +++ b/lib/include/srslte/interfaces/pdcp_interface_types.h @@ -138,6 +138,10 @@ public: // bool do_rohc; }; +// Specifies in which direction security (integrity and ciphering) are enabled for PDCP +enum srslte_direction_t { DIRECTION_NONE = 0, DIRECTION_TX, DIRECTION_RX, DIRECTION_TXRX, DIRECTION_N_ITEMS }; +static const char* srslte_direction_text[DIRECTION_N_ITEMS] = {"none", "tx", "rx", "tx/rx"}; + } // namespace srslte #endif // SRSLTE_PDCP_INTERFACE_TYPES_H diff --git a/lib/include/srslte/interfaces/rrc_interface_types.h b/lib/include/srslte/interfaces/rrc_interface_types.h index ec0a97726..0fc7354a5 100644 --- a/lib/include/srslte/interfaces/rrc_interface_types.h +++ b/lib/include/srslte/interfaces/rrc_interface_types.h @@ -104,6 +104,12 @@ struct plmn_id_t { } return from_number(mcc_num, mnc_num); } + int to_number(uint16_t* mcc_num, uint16_t* mnc_num) const + { + srslte::bytes_to_mcc(&mcc[0], mcc_num); + srslte::bytes_to_mnc(&mnc[0], mnc_num, nof_mnc_digits); + return SRSLTE_SUCCESS; + } std::string to_string() const { std::string mcc_str, mnc_str; diff --git a/lib/include/srslte/interfaces/ue_interfaces.h b/lib/include/srslte/interfaces/ue_interfaces.h index bf9dc47a7..f1fb16c18 100644 --- a/lib/include/srslte/interfaces/ue_interfaces.h +++ b/lib/include/srslte/interfaces/ue_interfaces.h @@ -163,10 +163,10 @@ public: const static int MAX_FOUND_PLMNS = 16; virtual ~rrc_interface_nas() = default; - 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 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 bool plmn_search() = 0; virtual void plmn_select(srslte::plmn_id_t plmn_id) = 0; virtual bool connection_request(srslte::establishment_cause_t cause, diff --git a/lib/include/srslte/interfaces/ue_nr_interfaces.h b/lib/include/srslte/interfaces/ue_nr_interfaces.h new file mode 100644 index 000000000..525feb23a --- /dev/null +++ b/lib/include/srslte/interfaces/ue_nr_interfaces.h @@ -0,0 +1,96 @@ +/* + * 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/. + * + */ + +#ifndef SRSLTE_UE_NR_INTERFACES_H +#define SRSLTE_UE_NR_INTERFACES_H + +#include + +#include "srslte/common/interfaces_common.h" + +namespace srsue { + +class rrc_interface_phy_nr +{ +public: + virtual void in_sync() = 0; + virtual void out_of_sync() = 0; + virtual void run_tti(const uint32_t tti) = 0; +}; + +class mac_interface_phy_nr +{ +public: + typedef struct { + srslte::unique_byte_buffer_t tb[SRSLTE_MAX_TB]; + uint32_t pid; + uint16_t rnti; + uint32_t tti; + } mac_nr_grant_dl_t; + + typedef struct { + uint32_t pid; + uint16_t rnti; + uint32_t tti; + uint32_t tbs; + } mac_nr_grant_ul_t; + + virtual int sf_indication(const uint32_t tti) = 0; ///< FIXME: rename to slot indication + + /// Indicate succussfully received TB to MAC. The TB buffer is allocated in the PHY and handed as unique_ptr to MAC + virtual void tb_decoded(const uint32_t cc_idx, mac_nr_grant_dl_t& grant) = 0; + + /// Indicate reception of UL grant (only TBS is provided). Buffer for resulting MAC PDU is provided by MAC and is + /// passed as pointer to PHY during tx_reuqest + virtual void new_grant_ul(const uint32_t cc_idx, const mac_nr_grant_ul_t& grant) = 0; +}; + +class mac_interface_rrc_nr +{}; + +class phy_interface_mac_nr +{ +public: + typedef struct { + uint32_t tti; + uint32_t tb_len; + uint8_t* data; // always a pointer in our case + } tx_request_t; + + virtual int tx_request(const tx_request_t& request) = 0; +}; + +class phy_interface_rrc_nr +{}; + +// Combined interface for PHY to access stack (MAC and RRC) +class stack_interface_phy_nr : public mac_interface_phy_nr, + public rrc_interface_phy_nr, + public srslte::stack_interface_phy_nr +{}; + +// Combined interface for stack (MAC and RRC) to access PHY +class phy_interface_stack_nr : public phy_interface_mac_nr, public phy_interface_rrc_nr +{}; + +} // namespace srsue + +#endif // SRSLTE_UE_NR_INTERFACES_H diff --git a/lib/include/srslte/upper/pdcp_entity_base.h b/lib/include/srslte/upper/pdcp_entity_base.h index 48a8d6e7c..426477766 100644 --- a/lib/include/srslte/upper/pdcp_entity_base.h +++ b/lib/include/srslte/upper/pdcp_entity_base.h @@ -52,10 +52,6 @@ typedef enum { } pdcp_d_c_t; static const char pdcp_d_c_text[PDCP_D_C_N_ITEMS][20] = {"Control PDU", "Data PDU"}; -// Specifies in which direction security (integrity and ciphering) are enabled for PDCP -typedef enum { DIRECTION_NONE = 0, DIRECTION_TX, DIRECTION_RX, DIRECTION_TXRX, DIRECTION_N_ITEMS } srslte_direction_t; -static const char srslte_direction_text[DIRECTION_N_ITEMS][6] = {"none", "tx", "rx", "tx/rx"}; - /**************************************************************************** * PDCP Entity interface * Common interface for LTE and NR PDCP entities @@ -64,6 +60,7 @@ class pdcp_entity_base { public: pdcp_entity_base(srslte::task_handler_interface* task_executor_, srslte::log_ref log_); + pdcp_entity_base(pdcp_entity_base&&) = default; virtual ~pdcp_entity_base(); virtual void reset() = 0; virtual void reestablish() = 0; diff --git a/lib/src/asn1/rrc_asn1_utils.cc b/lib/src/asn1/rrc_asn1_utils.cc index 99b7ac497..ce694a10c 100644 --- a/lib/src/asn1/rrc_asn1_utils.cc +++ b/lib/src/asn1/rrc_asn1_utils.cc @@ -59,6 +59,27 @@ void to_asn1(asn1::rrc::plmn_id_s* asn1_type, const plmn_id_t& cfg) std::copy(&cfg.mnc[0], &cfg.mnc[cfg.nof_mnc_digits], &asn1_type->mnc[0]); } +plmn_id_t make_plmn_id_t(const asn1::fixed_octstring<3, true>& asn1_type) // used for NGAP/S1AP +{ + plmn_id_t plmn; + uint16_t mcc, mnc; + uint32_t encoded_plmn = asn1_type.to_number(); + // uint32_t encoded_plmn = (asn1_type[0] << 16u) + (asn1_type[1] << 8u) + (asn1_type[2] << 0u); + s1ap_plmn_to_mccmnc(encoded_plmn, &mcc, &mnc); + plmn.from_number(mcc, mnc); + return plmn; +} + +void to_asn1(asn1::fixed_octstring<3, true>* asn1_type, const plmn_id_t& cfg) +{ + uint16_t mcc, mnc; + cfg.to_number(&mcc, &mnc); + uint32_t encoded_plmn; + s1ap_mccmnc_to_plmn(mcc, mnc, &encoded_plmn); + // uint32_t tmp32 = htonl(encoded_plmn); + asn1_type->from_number(encoded_plmn); +} + /*************************** * s-TMSI **************************/ diff --git a/lib/test/asn1/rrc_asn1_decoder.cc b/lib/test/asn1/rrc_asn1_decoder.cc index b70474ca7..63a79c5f6 100644 --- a/lib/test/asn1/rrc_asn1_decoder.cc +++ b/lib/test/asn1/rrc_asn1_decoder.cc @@ -71,7 +71,7 @@ int main(int argc, char** argv) uint8_t* rrc_msg = NULL; int verbose = 0; char* file = NULL; - int type = -1; + int type = -1; if (argc < 2) { printf("Please only call me with one parameter\n"); diff --git a/srsenb/test/upper/plmn_test.cc b/srsenb/test/upper/plmn_test.cc index cb8b796e7..3eb2d847f 100644 --- a/srsenb/test/upper/plmn_test.cc +++ b/srsenb/test/upper/plmn_test.cc @@ -24,6 +24,7 @@ #include "srslte/asn1/rrc_asn1_utils.h" #include "srslte/common/bcd_helpers.h" #include "srslte/interfaces/rrc_interface_types.h" +#include //for inet_ntop() #include using namespace asn1::rrc; @@ -92,9 +93,11 @@ int rrc_plmn_test() int s1ap_plmn_test() { - uint16_t mcc = 0xF123; - uint16_t mnc = 0xFF45; - uint32_t plmn; + uint16_t mcc = 0xF123; + uint16_t mnc = 0xFF45; + uint32_t plmn; + srslte::plmn_id_t srslte_plmn, srslte_plmn2; + asn1::fixed_octstring<3, true> s1ap_plmn{}; // 2-digit MNC test srslte::s1ap_mccmnc_to_plmn(mcc, mnc, &plmn); @@ -103,13 +106,34 @@ int s1ap_plmn_test() TESTASSERT(mcc == 0xF123); TESTASSERT(mnc == 0xFF45); + // Test MCC/MNC --> S1AP + srslte_plmn.from_number(mcc, mnc); + TESTASSERT(srslte_plmn.to_string() == "12345"); + srslte::to_asn1(&s1ap_plmn, srslte_plmn); + TESTASSERT(s1ap_plmn[0] == ((uint8_t*)&plmn)[2]); + TESTASSERT(s1ap_plmn[1] == ((uint8_t*)&plmn)[1]); + TESTASSERT(s1ap_plmn[2] == ((uint8_t*)&plmn)[0]); + srslte_plmn2 = srslte::make_plmn_id_t(s1ap_plmn); + TESTASSERT(srslte_plmn2 == srslte_plmn); + // 3-digit MNC test mnc = 0xF456; srslte::s1ap_mccmnc_to_plmn(mcc, mnc, &plmn); - TESTASSERT(plmn == 0x216354); + TESTASSERT(plmn == 0x214365); srslte::s1ap_plmn_to_mccmnc(plmn, &mcc, &mnc); TESTASSERT(mcc == 0xF123); TESTASSERT(mnc == 0xF456); + + // Test MCC/MNC --> S1AP + srslte_plmn.from_number(mcc, mnc); + TESTASSERT(srslte_plmn.to_string() == "123456"); + srslte::to_asn1(&s1ap_plmn, srslte_plmn); + TESTASSERT(s1ap_plmn[0] == ((uint8_t*)&plmn)[2]); + TESTASSERT(s1ap_plmn[1] == ((uint8_t*)&plmn)[1]); + TESTASSERT(s1ap_plmn[2] == ((uint8_t*)&plmn)[0]); + srslte_plmn2 = srslte::make_plmn_id_t(s1ap_plmn); + TESTASSERT(srslte_plmn2 == srslte_plmn); + return 0; }