/** * Copyright 2013-2021 Software Radio Systems Limited * * This file is part of srsRAN. * * srsRAN 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. * * srsRAN 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 SRSUE_PHY_H #define SRSUE_PHY_H #include "phy_common.h" #include "phy_metrics.h" #include "srsran/common/block_queue.h" #include "srsran/common/threads.h" #include "srsran/common/trace.h" #include "srsran/interfaces/phy_interface_types.h" #include "srsran/interfaces/radio_interfaces.h" #include "srsran/radio/radio.h" #include "srsran/srslog/srslog.h" #include "srsran/srsran.h" #include "srsue/hdr/phy/lte/worker_pool.h" #include "srsue/hdr/phy/nr/worker_pool.h" #include "srsue/hdr/phy/ue_lte_phy_base.h" #include "srsue/hdr/phy/ue_nr_phy_base.h" #include "sync.h" namespace srsue { typedef _Complex float cf_t; class phy_cmd_proc : public srsran::thread { public: phy_cmd_proc() : thread("PHY_CMD") { start(); } ~phy_cmd_proc() { stop(); } void add_cmd(std::function cmd) { cmd_queue.push(cmd); } void stop() { if (running) { add_cmd([this]() { running = false; }); wait_thread_finish(); } } private: void run_thread() { std::function cmd; while (running) { cmd = cmd_queue.wait_pop(); cmd(); } } bool running = true; // Queue for commands srsran::block_queue > cmd_queue; }; class phy final : public ue_lte_phy_base, public ue_nr_phy_base, public srsran::thread { public: explicit phy() : logger_phy(srslog::fetch_basic_logger("PHY")), logger_phy_lib(srslog::fetch_basic_logger("PHY_LIB")), lte_workers(MAX_WORKERS), nr_workers(MAX_WORKERS), common(logger_phy), sfsync(logger_phy, logger_phy_lib), prach_buffer(logger_phy), thread("PHY") {} ~phy() final { stop(); } // Init defined in base class int init(const phy_args_t& args_) final; // Init for LTE PHYs int init(const phy_args_t& args_, stack_interface_phy_lte* stack_, srsran::radio_interface_phy* radio_) final; void stop() final; void wait_initialize() final; bool is_initiated(); void get_metrics(const srsran::srsran_rat_t& rat, phy_metrics_t* m) final; void srsran_phy_logger(phy_logger_level_t log_level, char* str); void radio_overflow() final; void radio_failure() final; /********** RRC INTERFACE ********************/ bool cell_search() final; bool cell_select(phy_cell_t cell) final; // Sets the new PHY configuration for the given CC. The configuration is applied in the background. The notify() // function will be called when the reconfiguration is completed. Unless the PRACH configuration has changed, the // reconfiguration will not take more than 3 ms bool set_config(const srsran::phy_cfg_t& config, uint32_t cc_idx) final; // Adds or modifies the cell configuration for a given CC. If the EARFCN has changed w.r.t. the previous value, or if // the cell is new, this function might take a few hundred ms to complete, depending on the radio bool set_scell(srsran_cell_t cell_info, uint32_t cc_idx, uint32_t earfcn) final; // Applies a TDD configuration in the background. This function will take less than 3 ms to execute. void set_config_tdd(srsran_tdd_config_t& tdd_config) final; // Todo void set_config_mbsfn_sib2(srsran::mbsfn_sf_cfg_t* cfg_list, uint32_t nof_cfgs) final; void set_config_mbsfn_sib13(const srsran::sib13_t& sib13) final; void set_config_mbsfn_mcch(const srsran::mcch_msg_t& mcch) final; // This function applies the new configuration immediately void set_cells_to_meas(uint32_t earfcn, const std::set& pci) final; // This function applies the new configuration immediately void meas_stop() final; // also MAC interface bool cell_is_camping() final; /********** MAC INTERFACE ********************/ /* Transmits PRACH in the next opportunity */ void prach_send(uint32_t preamble_idx, int allowed_subframe, float target_power_dbm, float ta_base_sec) final; prach_info_t prach_get_info() final; /* Indicates the transmission of a SR signal in the next opportunity */ void sr_send() final; int sr_last_tx_tti() final; // Time advance commands void set_timeadv_rar(uint32_t tti, uint32_t ta_cmd) final; void set_timeadv(uint32_t tti, uint32_t ta_cmd) final; /* Activate / Disactivate SCell*/ void deactivate_scells() final; void set_activation_deactivation_scell(uint32_t cmd, uint32_t tti) final; /* Sets RAR dci payload */ void set_rar_grant(uint8_t grant_payload[SRSRAN_RAR_GRANT_LEN], uint16_t rnti) final; /*Set MAC->PHY MCH period stopping point*/ void set_mch_period_stop(uint32_t stop) final; float get_phr() final; float get_pathloss_db() final; uint32_t get_current_tti() final; void start_plot() final; const static int MAX_WORKERS = 4; const static int DEFAULT_WORKERS = 4; std::string get_type() final { return "lte_soft"; } int init(const phy_args_nr_t& args_, stack_interface_phy_nr* stack_, srsran::radio_interface_phy* radio_) final; bool set_config(const srsran::phy_cfg_nr_t& cfg) final; int set_ul_grant(uint32_t rx_tti, std::array packed_ul_grant, uint16_t rnti, srsran_rnti_type_t rnti_type) final; void send_prach(const uint32_t prach_occasion, const int preamble_index, const float preamble_received_target_power, const float ta_base_sec = 0.0f) final; int tx_request(const tx_request_t& request) final; void set_earfcn(std::vector earfcns) final; bool has_valid_sr_resource(uint32_t sr_id) final; void clear_pending_grants() final; private: void run_thread() final; void configure_prach_params(); void reset(); std::mutex config_mutex; std::condition_variable config_cond; std::atomic is_configured = {false}; const static int SF_RECV_THREAD_PRIO = 0; const static int WORKERS_THREAD_PRIO = 2; srsran::radio_interface_phy* radio = nullptr; srslog::basic_logger& logger_phy; srslog::basic_logger& logger_phy_lib; srsue::stack_interface_phy_lte* stack = nullptr; lte::worker_pool lte_workers; nr::worker_pool nr_workers; phy_common common; sync sfsync; prach prach_buffer; srsran_prach_cfg_t prach_cfg = {}; srsran_tdd_config_t tdd_config = {}; srsran::phy_cfg_t config = {}; phy_args_t args = {}; // Since cell_search/cell_select operations take a lot of time, we use another queue to process the other commands // in parallel and avoid accumulating in the queue phy_cmd_proc cmd_worker_cell, cmd_worker; // Tracks the current selected cell (last call to cell_select) srsran_cell_t selected_cell = {}; static void set_default_args(phy_args_t& args); bool check_args(const phy_args_t& args); }; } // namespace srsue #endif // SRSUE_PHY_H