add srsue::rrc_nr srsue::ue_stack_nr
This commit is contained in:
Francisco Paisana
Francisco Paisana
parent
6a164e032d
commit
4cf756434f
|
|
@ -34,10 +34,6 @@ namespace srsue {
|
|||
|
||||
struct mac_nr_args_t {
|
||||
srsue::pcap_args_t pcap;
|
||||
|
||||
// Add args
|
||||
std::string log_level;
|
||||
uint32_t log_hex_limit;
|
||||
};
|
||||
|
||||
class mac_nr : public mac_interface_phy_nr, public mac_interface_rrc_nr
|
||||
|
|
|
|||
|
|
@ -0,0 +1,147 @@
|
|||
/*
|
||||
* Copyright 2013-2020 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 SRSUE_UE_STACK_NR_H
|
||||
#define SRSUE_UE_STACK_NR_H
|
||||
|
||||
#include <functional>
|
||||
#include <pthread.h>
|
||||
#include <stdarg.h>
|
||||
#include <string>
|
||||
|
||||
#include "mac/mac_nr.h"
|
||||
#include "rrc/rrc_nr.h"
|
||||
#include "srslte/radio/radio.h"
|
||||
#include "srslte/upper/pdcp.h"
|
||||
#include "srslte/upper/rlc.h"
|
||||
#include "upper/nas.h"
|
||||
#include "upper/usim.h"
|
||||
|
||||
#include "srslte/common/buffer_pool.h"
|
||||
#include "srslte/common/log_filter.h"
|
||||
#include "srslte/common/mac_nr_pcap.h"
|
||||
#include "srslte/common/multiqueue.h"
|
||||
#include "srslte/common/thread_pool.h"
|
||||
#include "srslte/interfaces/ue_nr_interfaces.h"
|
||||
|
||||
#include "srsue/hdr/ue_metrics_interface.h"
|
||||
#include "ue_stack_base.h"
|
||||
|
||||
namespace srsue {
|
||||
|
||||
/** \brief L2/L3 stack class for 5G/NR UEs.
|
||||
*
|
||||
* This class wraps all L2/L3 blocks and provides a single interface towards the PHY.
|
||||
*/
|
||||
|
||||
class ue_stack_nr final : public ue_stack_base,
|
||||
public stack_interface_phy_nr,
|
||||
public stack_interface_gw,
|
||||
public stack_interface_rrc,
|
||||
public srslte::thread
|
||||
{
|
||||
public:
|
||||
ue_stack_nr(srslte::logger* logger_);
|
||||
~ue_stack_nr();
|
||||
|
||||
std::string get_type() final;
|
||||
|
||||
int init(const stack_args_t& args_);
|
||||
int init(const stack_args_t& args_, phy_interface_stack_nr* phy_, gw_interface_stack* gw_);
|
||||
bool switch_on() final;
|
||||
bool switch_off() final;
|
||||
void stop();
|
||||
|
||||
bool get_metrics(stack_metrics_t* metrics);
|
||||
bool is_rrc_connected();
|
||||
|
||||
// RRC interface for PHY
|
||||
void in_sync() final;
|
||||
void out_of_sync() final;
|
||||
void run_tti(uint32_t tti) final;
|
||||
|
||||
// MAC interface for PHY
|
||||
int sf_indication(const uint32_t tti)
|
||||
{
|
||||
mac->sf_indication(tti);
|
||||
return SRSLTE_SUCCESS;
|
||||
}
|
||||
void tb_decoded(const uint32_t cc_idx, mac_nr_grant_dl_t& grant) { mac->tb_decoded(cc_idx, grant); }
|
||||
void new_grant_ul(const uint32_t cc_idx, const mac_nr_grant_ul_t& grant) { mac->new_grant_ul(cc_idx, grant); }
|
||||
|
||||
// Interface for GW
|
||||
void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking) final;
|
||||
bool is_lcid_enabled(uint32_t lcid) final { return pdcp->is_lcid_enabled(lcid); }
|
||||
|
||||
// Interface for RRC
|
||||
void start_cell_search() final;
|
||||
void start_cell_select(const phy_interface_rrc_lte::phy_cell_t* cell) final;
|
||||
srslte::tti_point get_current_tti() { return srslte::tti_point{0}; };
|
||||
|
||||
// Task Handling interface
|
||||
srslte::timer_handler::unique_timer get_unique_timer() final { return timers.get_unique_timer(); }
|
||||
srslte::task_multiqueue::queue_handler make_task_queue() final { return pending_tasks.get_queue_handler(); }
|
||||
void enqueue_background_task(std::function<void(uint32_t)> f) final;
|
||||
void notify_background_task_result(srslte::move_task_t task) final;
|
||||
void defer_callback(uint32_t duration_ms, std::function<void()> func) final;
|
||||
void defer_task(srslte::move_task_t task) final;
|
||||
|
||||
private:
|
||||
void run_thread() final;
|
||||
void run_tti_impl(uint32_t tti);
|
||||
void stop_impl();
|
||||
|
||||
bool running = false;
|
||||
srsue::stack_args_t args = {};
|
||||
|
||||
// timers
|
||||
srslte::timer_handler timers;
|
||||
|
||||
// UE stack logging
|
||||
srslte::logger* logger = nullptr;
|
||||
srslte::log_ref rlc_log;
|
||||
srslte::log_ref pdcp_log;
|
||||
srslte::log_ref pool_log;
|
||||
|
||||
// stack components
|
||||
std::unique_ptr<mac_nr> mac;
|
||||
std::unique_ptr<rrc_nr> rrc;
|
||||
std::unique_ptr<srslte::rlc> rlc;
|
||||
std::unique_ptr<srslte::pdcp> pdcp;
|
||||
|
||||
std::unique_ptr<srslte::mac_nr_pcap> mac_pcap;
|
||||
|
||||
// RAT-specific interfaces
|
||||
phy_interface_stack_nr* phy = nullptr;
|
||||
gw_interface_stack* gw = nullptr;
|
||||
|
||||
// Thread
|
||||
static const int STACK_MAIN_THREAD_PRIO = -1; // Use default high-priority below UHD
|
||||
|
||||
srslte::task_multiqueue pending_tasks;
|
||||
int sync_queue_id = -1, ue_queue_id = -1, gw_queue_id = -1, mac_queue_id = -1, background_queue_id = -1;
|
||||
srslte::task_thread_pool background_tasks; ///< Thread pool used for long, low-priority tasks
|
||||
std::vector<srslte::move_task_t> deferred_stack_tasks; ///< enqueues stack tasks from within. Avoids locking
|
||||
};
|
||||
|
||||
} // namespace srsue
|
||||
|
||||
#endif // SRSUE_UE_STACK_NR_H
|
||||
|
|
@ -23,4 +23,9 @@ add_subdirectory(rrc)
|
|||
add_subdirectory(upper)
|
||||
|
||||
set(SOURCES ue_stack_lte.cc)
|
||||
add_library(srsue_stack STATIC ${SOURCES})
|
||||
add_library(srsue_stack STATIC ${SOURCES})
|
||||
|
||||
if(ENABLE_5GNR)
|
||||
set(SOURCES ue_stack_nr.cc)
|
||||
add_library(srsue_nr_stack STATIC ${SOURCES})
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -30,9 +30,6 @@ mac_nr::mac_nr() : pool(srslte::byte_buffer_pool::get_instance()), log_h("MAC")
|
|||
{
|
||||
tx_buffer = srslte::allocate_unique_buffer(*pool);
|
||||
rlc_buffer = srslte::allocate_unique_buffer(*pool);
|
||||
|
||||
log_h->set_level(args.log_level);
|
||||
log_h->set_hex_limit(args.log_hex_limit);
|
||||
}
|
||||
|
||||
mac_nr::~mac_nr()
|
||||
|
|
|
|||
|
|
@ -23,5 +23,5 @@ add_library(srsue_rrc STATIC ${SOURCES})
|
|||
|
||||
if(ENABLE_5GNR)
|
||||
set(SOURCES rrc_nr.cc)
|
||||
add_library(srsgnb_rrc STATIC ${SOURCES})
|
||||
add_library(srsue_nr_rrc STATIC ${SOURCES})
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,268 @@
|
|||
/*
|
||||
* Copyright 2013-2020 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/.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "srsue/hdr/stack/ue_stack_nr.h"
|
||||
#include "srslte/srslte.h"
|
||||
|
||||
using namespace srslte;
|
||||
|
||||
namespace srsue {
|
||||
|
||||
ue_stack_nr::ue_stack_nr(srslte::logger* logger_) :
|
||||
logger(logger_),
|
||||
timers(64),
|
||||
thread("STACK"),
|
||||
pending_tasks(1024),
|
||||
background_tasks(2),
|
||||
rlc_log("RLC"),
|
||||
pdcp_log("PDCP"),
|
||||
pool_log("POOL")
|
||||
{
|
||||
mac.reset(new mac_nr());
|
||||
pdcp.reset(new srslte::pdcp(this, "PDCP"));
|
||||
rlc.reset(new srslte::rlc("RLC"));
|
||||
rrc.reset(new rrc_nr());
|
||||
|
||||
// setup logging for pool, RLC and PDCP
|
||||
pool_log->set_level(srslte::LOG_LEVEL_ERROR);
|
||||
byte_buffer_pool::get_instance()->set_log(pool_log.get());
|
||||
|
||||
ue_queue_id = pending_tasks.add_queue();
|
||||
sync_queue_id = pending_tasks.add_queue();
|
||||
gw_queue_id = pending_tasks.add_queue();
|
||||
mac_queue_id = pending_tasks.add_queue();
|
||||
background_queue_id = pending_tasks.add_queue();
|
||||
|
||||
background_tasks.start();
|
||||
}
|
||||
|
||||
ue_stack_nr::~ue_stack_nr()
|
||||
{
|
||||
stop();
|
||||
}
|
||||
|
||||
std::string ue_stack_nr::get_type()
|
||||
{
|
||||
return "nr";
|
||||
}
|
||||
|
||||
int ue_stack_nr::init(const stack_args_t& args_, phy_interface_stack_nr* phy_, gw_interface_stack* gw_)
|
||||
{
|
||||
phy = phy_;
|
||||
gw = gw_;
|
||||
return init(args_);
|
||||
}
|
||||
|
||||
int ue_stack_nr::init(const stack_args_t& args_)
|
||||
{
|
||||
args = args_;
|
||||
|
||||
srslte::logmap::register_log(std::unique_ptr<srslte::log>{new srslte::log_filter{"MAC", logger, true}});
|
||||
|
||||
srslte::log_ref mac_log{"MAC"};
|
||||
mac_log->set_level(args.log.mac_level);
|
||||
mac_log->set_hex_limit(args.log.mac_hex_limit);
|
||||
rlc_log->set_level(args.log.rlc_level);
|
||||
rlc_log->set_hex_limit(args.log.rlc_hex_limit);
|
||||
pdcp_log->set_level(args.log.pdcp_level);
|
||||
pdcp_log->set_hex_limit(args.log.pdcp_hex_limit);
|
||||
|
||||
mac_nr_args_t mac_args = {};
|
||||
mac_args.pcap = args.pcap;
|
||||
mac->init(mac_args, phy, rlc.get(), &timers, this);
|
||||
rlc->init(pdcp.get(), rrc.get(), &timers, 0 /* RB_ID_SRB0 */);
|
||||
pdcp->init(rlc.get(), rrc.get(), gw);
|
||||
|
||||
// TODO: where to put RRC args?
|
||||
rrc_nr_args_t rrc_args = {};
|
||||
rrc_args.log_level = args.log.rrc_level;
|
||||
rrc_args.log_hex_limit = args.log.rrc_hex_limit;
|
||||
rrc_args.coreless.drb_lcid = 4;
|
||||
rrc_args.coreless.ip_addr = "192.168.1.3";
|
||||
rrc->init(phy, mac.get(), rlc.get(), pdcp.get(), gw, &timers, this, rrc_args);
|
||||
|
||||
// statically setup TUN (will be done through RRC later)
|
||||
char* err_str = nullptr;
|
||||
if (gw->setup_if_addr(rrc_args.coreless.drb_lcid,
|
||||
LIBLTE_MME_PDN_TYPE_IPV4,
|
||||
htonl(inet_addr(rrc_args.coreless.ip_addr.c_str())),
|
||||
nullptr,
|
||||
err_str)) {
|
||||
printf("Error configuring TUN interface\n");
|
||||
}
|
||||
|
||||
running = true;
|
||||
start(STACK_MAIN_THREAD_PRIO);
|
||||
|
||||
return SRSLTE_SUCCESS;
|
||||
}
|
||||
|
||||
void ue_stack_nr::stop()
|
||||
{
|
||||
if (running) {
|
||||
pending_tasks.try_push(ue_queue_id, [this]() { stop_impl(); });
|
||||
wait_thread_finish();
|
||||
}
|
||||
}
|
||||
|
||||
void ue_stack_nr::stop_impl()
|
||||
{
|
||||
running = false;
|
||||
|
||||
rrc->stop();
|
||||
|
||||
rlc->stop();
|
||||
pdcp->stop();
|
||||
mac->stop();
|
||||
|
||||
if (mac_pcap != nullptr) {
|
||||
mac_pcap.reset();
|
||||
}
|
||||
}
|
||||
|
||||
bool ue_stack_nr::switch_on()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ue_stack_nr::switch_off()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ue_stack_nr::get_metrics(stack_metrics_t* metrics)
|
||||
{
|
||||
// mac.get_metrics(metrics->mac);
|
||||
rlc->get_metrics(metrics->rlc);
|
||||
// rrc.get_metrics(metrics->rrc);
|
||||
return true;
|
||||
}
|
||||
|
||||
void ue_stack_nr::run_thread()
|
||||
{
|
||||
while (running) {
|
||||
srslte::move_task_t task{};
|
||||
if (pending_tasks.wait_pop(&task) >= 0) {
|
||||
task();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/***********************************************************************************************************************
|
||||
* Stack Interfaces
|
||||
**********************************************************************************************************************/
|
||||
|
||||
/********************
|
||||
* GW Interface
|
||||
*******************/
|
||||
|
||||
/**
|
||||
* Push GW SDU to stack
|
||||
* @param lcid
|
||||
* @param sdu
|
||||
* @param blocking
|
||||
*/
|
||||
void ue_stack_nr::write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking)
|
||||
{
|
||||
if (pdcp != nullptr) {
|
||||
std::pair<bool, move_task_t> ret = pending_tasks.try_push(
|
||||
gw_queue_id,
|
||||
std::bind([this, lcid, blocking](
|
||||
srslte::unique_byte_buffer_t& sdu) { pdcp->write_sdu(lcid, std::move(sdu), blocking); },
|
||||
std::move(sdu)));
|
||||
if (not ret.first) {
|
||||
pdcp_log->warning("GW SDU with lcid=%d was discarded.\n", lcid);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/********************
|
||||
* SYNC Interface
|
||||
*******************/
|
||||
|
||||
/**
|
||||
* Sync thread signal that it is in sync
|
||||
*/
|
||||
void ue_stack_nr::in_sync()
|
||||
{
|
||||
// pending_tasks.push(sync_queue_id, task_t{[this](task_t*) { rrc.in_sync(); }});
|
||||
}
|
||||
|
||||
void ue_stack_nr::out_of_sync()
|
||||
{
|
||||
// pending_tasks.push(sync_queue_id, task_t{[this](task_t*) { rrc.out_of_sync(); }});
|
||||
}
|
||||
|
||||
void ue_stack_nr::run_tti(uint32_t tti)
|
||||
{
|
||||
// pending_tasks.push(sync_queue_id, task_t{[this, tti](task_t*) { run_tti_impl(tti); }});
|
||||
}
|
||||
|
||||
void ue_stack_nr::run_tti_impl(uint32_t tti)
|
||||
{
|
||||
#if 0
|
||||
mac->run_tti(tti);
|
||||
rrc->run_tti(tti);
|
||||
nas->run_tti(tti);
|
||||
timers->step_all();
|
||||
#endif
|
||||
}
|
||||
|
||||
/********************
|
||||
* low MAC Interface
|
||||
*******************/
|
||||
|
||||
void ue_stack_nr::start_cell_search()
|
||||
{
|
||||
// not implemented
|
||||
}
|
||||
|
||||
void ue_stack_nr::start_cell_select(const phy_interface_rrc_lte::phy_cell_t* cell)
|
||||
{
|
||||
// not implemented
|
||||
}
|
||||
|
||||
/***************************
|
||||
* Task Handling Interface
|
||||
**************************/
|
||||
|
||||
void ue_stack_nr::enqueue_background_task(std::function<void(uint32_t)> f)
|
||||
{
|
||||
background_tasks.push_task(std::move(f));
|
||||
}
|
||||
|
||||
void ue_stack_nr::notify_background_task_result(srslte::move_task_t task)
|
||||
{
|
||||
// run the notification in the stack thread
|
||||
pending_tasks.push(background_queue_id, std::move(task));
|
||||
}
|
||||
|
||||
void ue_stack_nr::defer_callback(uint32_t duration_ms, std::function<void()> func)
|
||||
{
|
||||
timers.defer_callback(duration_ms, func);
|
||||
}
|
||||
|
||||
void ue_stack_nr::defer_task(srslte::move_task_t task)
|
||||
{
|
||||
deferred_stack_tasks.push_back(std::move(task));
|
||||
}
|
||||
|
||||
} // namespace srsue
|
||||
Loading…
Reference in New Issue