mirror of https://github.com/pvnis/srsRAN_4G.git
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
877 lines
30 KiB
C++
877 lines
30 KiB
C++
/*
|
|
* 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 <string>
|
|
|
|
#include "rrc_interface_types.h"
|
|
#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/channel/channel.h"
|
|
#include "srslte/phy/rf/rf.h"
|
|
|
|
namespace srsue {
|
|
|
|
typedef enum {
|
|
AUTH_OK,
|
|
AUTH_FAILED,
|
|
AUTH_SYNCH_FAILURE
|
|
} auth_result_t;
|
|
|
|
// 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(srslte::plmn_id_t* 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 int setup_if_addr(uint32_t lcid, uint8_t pdn_type, uint32_t ip_addr, uint8_t* ipv6_if_id, char* err_str) = 0;
|
|
virtual int apply_traffic_flow_template(const uint8_t& eps_bearer_id,
|
|
const uint8_t& lcid,
|
|
const LIBLTE_MME_TRAFFIC_FLOW_TEMPLATE_STRUCT* tft) = 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 leave_connected() = 0;
|
|
virtual void set_barring(barring_t barring) = 0;
|
|
virtual void paging(srslte::s_tmsi_t* ue_identity) = 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;
|
|
};
|
|
|
|
// 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 {
|
|
srslte::plmn_id_t 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(srslte::plmn_id_t plmn_id) = 0;
|
|
virtual bool connection_request(srslte::establishment_cause_t cause,
|
|
srslte::unique_byte_buffer_t dedicatedInfoNAS) = 0;
|
|
virtual void set_ue_identity(srslte::s_tmsi_t s_tmsi) = 0;
|
|
virtual bool is_connected() = 0;
|
|
virtual std::string get_rb_name(uint32_t lcid) = 0;
|
|
virtual uint32_t get_lcid_for_eps_bearer(const uint32_t& eps_bearer_id) = 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;
|
|
virtual void write_pdu(uint32_t lcid, srslte::unique_byte_buffer_t pdu) = 0;
|
|
};
|
|
|
|
// PDCP interface for RRC
|
|
class pdcp_interface_rrc
|
|
{
|
|
public:
|
|
virtual void reestablish() = 0;
|
|
virtual void reestablish(uint32_t lcid) = 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) = 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;
|
|
};
|
|
|
|
// 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;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
// 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, 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 suspend_bearer(uint32_t lcid) = 0;
|
|
virtual void resume_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;
|
|
virtual void write_sdu(uint32_t lcid, srslte::unique_byte_buffer_t sdu, bool blocking = true) = 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;
|
|
};
|
|
|
|
/** PHY interface
|
|
*
|
|
*/
|
|
|
|
typedef struct {
|
|
uint32_t radio_idx;
|
|
uint32_t channel_idx;
|
|
} carrier_map_t;
|
|
|
|
typedef struct {
|
|
std::string type;
|
|
srslte::phy_log_args_t log;
|
|
|
|
std::string dl_earfcn; // comma-separated list of EARFCNs
|
|
std::vector<uint32_t> 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 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 agc_enable;
|
|
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;
|
|
float force_ul_amplitude;
|
|
|
|
srslte::channel::args_t dl_channel_args;
|
|
srslte::channel::args_t ul_channel_args;
|
|
} 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;
|
|
bool rrc_enable_64qam;
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
// STACK interface for GW
|
|
class stack_interface_gw : public pdcp_interface_gw
|
|
{
|
|
public:
|
|
virtual bool switch_on() = 0;
|
|
};
|
|
|
|
class gw_interface_stack : public gw_interface_nas, public gw_interface_rrc, public gw_interface_pdcp
|
|
{
|
|
};
|
|
|
|
// 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
|