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.
642 lines
18 KiB
C++
642 lines
18 KiB
C++
/**
|
|
*
|
|
* \section COPYRIGHT
|
|
*
|
|
* Copyright 2013-2015 Software Radio Systems Limited
|
|
*
|
|
* \section LICENSE
|
|
*
|
|
* This file is part of the srsUE library.
|
|
*
|
|
* srsUE 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.
|
|
*
|
|
* srsUE 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_RRC_H
|
|
#define SRSUE_RRC_H
|
|
|
|
#include "pthread.h"
|
|
|
|
#include "rrc_common.h"
|
|
#include "srslte/common/buffer_pool.h"
|
|
#include "srslte/common/log.h"
|
|
#include "srslte/common/common.h"
|
|
#include "srslte/interfaces/ue_interfaces.h"
|
|
#include "srslte/common/security.h"
|
|
#include "srslte/common/threads.h"
|
|
#include "srslte/common/block_queue.h"
|
|
|
|
#include <math.h>
|
|
#include <map>
|
|
#include <queue>
|
|
|
|
typedef struct {
|
|
uint32_t ue_category;
|
|
uint32_t feature_group;
|
|
uint8_t supported_bands[LIBLTE_RRC_BAND_N_ITEMS];
|
|
uint32_t nof_supported_bands;
|
|
}rrc_args_t;
|
|
|
|
using srslte::byte_buffer_t;
|
|
|
|
namespace srsue {
|
|
|
|
class cell_t
|
|
{
|
|
public:
|
|
bool is_valid() {
|
|
return phy_cell.earfcn != 0 && srslte_cell_isvalid(&phy_cell.cell);
|
|
}
|
|
bool equals(cell_t *x) {
|
|
return equals(x->phy_cell.earfcn, x->phy_cell.cell.id);
|
|
}
|
|
bool equals(uint32_t earfcn, uint32_t pci) {
|
|
return earfcn == this->phy_cell.earfcn && pci == phy_cell.cell.id;
|
|
}
|
|
// NaN means an RSRP value has not yet been obtained. Keep then in the list and clean them if never updated
|
|
bool greater(cell_t *x) {
|
|
return rsrp > x->rsrp || isnan(rsrp);
|
|
}
|
|
bool plmn_equals(LIBLTE_RRC_PLMN_IDENTITY_STRUCT plmn_id) {
|
|
if (has_valid_sib1) {
|
|
for (uint32_t i = 0; i < sib1.N_plmn_ids; i++) {
|
|
if (plmn_id.mcc == sib1.plmn_id[i].id.mcc && plmn_id.mnc == sib1.plmn_id[i].id.mnc) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint32_t nof_plmns() {
|
|
if (has_valid_sib1) {
|
|
return sib1.N_plmn_ids;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
LIBLTE_RRC_PLMN_IDENTITY_STRUCT get_plmn(uint32_t idx) {
|
|
if (idx < sib1.N_plmn_ids && has_valid_sib1) {
|
|
return sib1.plmn_id[idx].id;
|
|
} else {
|
|
LIBLTE_RRC_PLMN_IDENTITY_STRUCT null;
|
|
null.mnc = 0;
|
|
null.mcc = 0;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
uint16_t get_tac() {
|
|
if (has_valid_sib1) {
|
|
return sib1.tracking_area_code;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
cell_t() {
|
|
phy_interface_rrc::phy_cell_t tmp = {};
|
|
cell_t(tmp, 0);
|
|
}
|
|
cell_t(phy_interface_rrc::phy_cell_t phy_cell, float rsrp) {
|
|
gettimeofday(&last_update, NULL);
|
|
this->has_valid_sib1 = false;
|
|
this->has_valid_sib2 = false;
|
|
this->has_valid_sib3 = false;
|
|
this->has_valid_sib13 = false;
|
|
this->phy_cell = phy_cell;
|
|
this->rsrp = rsrp;
|
|
in_sync = true;
|
|
bzero(&sib1, sizeof(sib1));
|
|
bzero(&sib2, sizeof(sib2));
|
|
bzero(&sib3, sizeof(sib3));
|
|
bzero(&sib13, sizeof(sib13));
|
|
}
|
|
|
|
uint32_t get_earfcn() {
|
|
return phy_cell.earfcn;
|
|
}
|
|
|
|
uint32_t get_pci() {
|
|
return phy_cell.cell.id;
|
|
}
|
|
|
|
void set_rsrp(float rsrp) {
|
|
if (!isnan(rsrp)) {
|
|
this->rsrp = rsrp;
|
|
}
|
|
in_sync = true;
|
|
gettimeofday(&last_update, NULL);
|
|
}
|
|
|
|
float get_rsrp() {
|
|
return rsrp;
|
|
}
|
|
|
|
void set_sib1(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_1_STRUCT *sib1) {
|
|
memcpy(&this->sib1, sib1, sizeof(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_1_STRUCT));
|
|
has_valid_sib1 = true;
|
|
}
|
|
void set_sib2(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_2_STRUCT *sib2) {
|
|
memcpy(&this->sib2, sib2, sizeof(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_2_STRUCT));
|
|
has_valid_sib2 = true;
|
|
}
|
|
void set_sib3(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_3_STRUCT *sib3) {
|
|
memcpy(&this->sib3, sib3, sizeof(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_3_STRUCT));
|
|
has_valid_sib3 = true;
|
|
}
|
|
void set_sib13(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_13_STRUCT *sib13) {
|
|
memcpy(&this->sib13, sib13, sizeof(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_13_STRUCT));
|
|
has_valid_sib13 = true;
|
|
}
|
|
|
|
uint32_t timeout_secs(struct timeval now) {
|
|
struct timeval t[3];
|
|
memcpy(&t[2], &now, sizeof(struct timeval));
|
|
memcpy(&t[1], &last_update, sizeof(struct timeval));
|
|
get_time_interval(t);
|
|
return t[0].tv_sec;
|
|
}
|
|
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_1_STRUCT *sib1ptr() {
|
|
return &sib1;
|
|
}
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_2_STRUCT *sib2ptr() {
|
|
return &sib2;
|
|
}
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_3_STRUCT *sib3ptr() {
|
|
return &sib3;
|
|
}
|
|
|
|
uint32_t get_cell_id() {
|
|
return sib1.cell_id;
|
|
}
|
|
|
|
bool has_sib1() {
|
|
return has_valid_sib1;
|
|
}
|
|
bool has_sib2() {
|
|
return has_valid_sib2;
|
|
}
|
|
bool has_sib3() {
|
|
return has_valid_sib3;
|
|
}
|
|
bool has_sib13() {
|
|
return has_valid_sib13;
|
|
}
|
|
|
|
bool has_sib(uint32_t index) {
|
|
switch(index) {
|
|
case 0:
|
|
return has_sib1();
|
|
case 1:
|
|
return has_sib2();
|
|
case 2:
|
|
return has_sib3();
|
|
case 12:
|
|
return has_sib13();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
uint16_t get_mcc() {
|
|
if (has_valid_sib1) {
|
|
if (sib1.N_plmn_ids > 0) {
|
|
return sib1.plmn_id[0].id.mcc;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint16_t get_mnc() {
|
|
if (has_valid_sib1) {
|
|
if (sib1.N_plmn_ids > 0) {
|
|
return sib1.plmn_id[0].id.mnc;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
phy_interface_rrc::phy_cell_t phy_cell;
|
|
bool in_sync;
|
|
|
|
private:
|
|
float rsrp;
|
|
struct timeval last_update;
|
|
|
|
bool has_valid_sib1;
|
|
bool has_valid_sib2;
|
|
bool has_valid_sib3;
|
|
bool has_valid_sib13;
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_1_STRUCT sib1;
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_2_STRUCT sib2;
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_3_STRUCT sib3;
|
|
LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_13_STRUCT sib13;
|
|
};
|
|
|
|
class rrc
|
|
:public rrc_interface_nas
|
|
,public rrc_interface_phy
|
|
,public rrc_interface_mac
|
|
,public rrc_interface_pdcp
|
|
,public rrc_interface_rlc
|
|
,public srslte::timer_callback
|
|
,public thread
|
|
{
|
|
public:
|
|
rrc();
|
|
~rrc();
|
|
|
|
void init(phy_interface_rrc *phy_,
|
|
mac_interface_rrc *mac_,
|
|
rlc_interface_rrc *rlc_,
|
|
pdcp_interface_rrc *pdcp_,
|
|
nas_interface_rrc *nas_,
|
|
usim_interface_rrc *usim_,
|
|
srslte::mac_interface_timers *mac_timers_,
|
|
srslte::log *rrc_log_);
|
|
|
|
void stop();
|
|
|
|
rrc_state_t get_state();
|
|
void set_args(rrc_args_t *args);
|
|
|
|
// Timeout callback interface
|
|
void timer_expired(uint32_t timeout_id);
|
|
void liblte_rrc_log(char *str);
|
|
|
|
// NAS interface
|
|
void write_sdu(uint32_t lcid, byte_buffer_t *sdu);
|
|
void enable_capabilities();
|
|
uint16_t get_mcc();
|
|
uint16_t get_mnc();
|
|
int plmn_search(found_plmn_t found_plmns[MAX_FOUND_PLMNS]);
|
|
void plmn_select(LIBLTE_RRC_PLMN_IDENTITY_STRUCT plmn_id);
|
|
bool connection_request(LIBLTE_RRC_CON_REQ_EST_CAUSE_ENUM cause,
|
|
srslte::byte_buffer_t *dedicatedInfoNAS);
|
|
void set_ue_idenity(LIBLTE_RRC_S_TMSI_STRUCT s_tmsi);
|
|
|
|
// PHY interface
|
|
void in_sync();
|
|
void out_of_sync();
|
|
void new_phy_meas(float rsrp, float rsrq, uint32_t tti, int earfcn, int pci);
|
|
|
|
// MAC interface
|
|
void ho_ra_completed(bool ra_successful);
|
|
void release_pucch_srs();
|
|
void run_tti(uint32_t tti);
|
|
void ra_problem();
|
|
|
|
// GW interface
|
|
bool is_connected(); // this is also NAS interface
|
|
bool have_drb();
|
|
|
|
// PDCP interface
|
|
void write_pdu(uint32_t lcid, byte_buffer_t *pdu);
|
|
void write_pdu_bcch_bch(byte_buffer_t *pdu);
|
|
void write_pdu_bcch_dlsch(byte_buffer_t *pdu);
|
|
void write_pdu_pcch(byte_buffer_t *pdu);
|
|
|
|
|
|
private:
|
|
|
|
typedef struct {
|
|
enum {
|
|
PCCH,
|
|
STOP
|
|
} command;
|
|
byte_buffer_t *pdu;
|
|
} cmd_msg_t;
|
|
|
|
bool running;
|
|
srslte::block_queue<cmd_msg_t> cmd_q;
|
|
void run_thread();
|
|
|
|
void process_pcch(byte_buffer_t *pdu);
|
|
|
|
srslte::byte_buffer_pool *pool;
|
|
srslte::log *rrc_log;
|
|
phy_interface_rrc *phy;
|
|
mac_interface_rrc *mac;
|
|
rlc_interface_rrc *rlc;
|
|
pdcp_interface_rrc *pdcp;
|
|
nas_interface_rrc *nas;
|
|
usim_interface_rrc *usim;
|
|
|
|
LIBLTE_RRC_UL_DCCH_MSG_STRUCT ul_dcch_msg;
|
|
LIBLTE_RRC_UL_CCCH_MSG_STRUCT ul_ccch_msg;
|
|
LIBLTE_RRC_DL_CCCH_MSG_STRUCT dl_ccch_msg;
|
|
LIBLTE_RRC_DL_DCCH_MSG_STRUCT dl_dcch_msg;
|
|
|
|
byte_buffer_t *dedicatedInfoNAS;
|
|
|
|
byte_buffer_t* byte_align_and_pack();
|
|
void send_ul_ccch_msg();
|
|
void send_ul_dcch_msg();
|
|
srslte::bit_buffer_t bit_buf;
|
|
|
|
pthread_mutex_t mutex;
|
|
|
|
rrc_state_t state;
|
|
uint8_t transaction_id;
|
|
LIBLTE_RRC_S_TMSI_STRUCT ueIdentity;
|
|
bool ueIdentity_configured;
|
|
|
|
bool drb_up;
|
|
|
|
rrc_args_t args;
|
|
|
|
uint32_t cell_clean_cnt;
|
|
|
|
uint16_t ho_src_rnti;
|
|
cell_t ho_src_cell;
|
|
phy_interface_rrc::phy_cfg_t previous_phy_cfg;
|
|
mac_interface_rrc::mac_cfg_t previous_mac_cfg;
|
|
bool pending_mob_reconf;
|
|
LIBLTE_RRC_CONNECTION_RECONFIGURATION_STRUCT mob_reconf;
|
|
|
|
uint8_t k_rrc_enc[32];
|
|
uint8_t k_rrc_int[32];
|
|
uint8_t k_up_enc[32];
|
|
uint8_t k_up_int[32]; // Not used: only for relay nodes (3GPP 33.401 Annex A.7)
|
|
|
|
srslte::CIPHERING_ALGORITHM_ID_ENUM cipher_algo;
|
|
srslte::INTEGRITY_ALGORITHM_ID_ENUM integ_algo;
|
|
|
|
std::map<uint32_t, LIBLTE_RRC_SRB_TO_ADD_MOD_STRUCT> srbs;
|
|
std::map<uint32_t, LIBLTE_RRC_DRB_TO_ADD_MOD_STRUCT> drbs;
|
|
|
|
// RRC constants and timers
|
|
srslte::mac_interface_timers *mac_timers;
|
|
uint32_t n310_cnt, N310;
|
|
uint32_t n311_cnt, N311;
|
|
uint32_t t300, t301, t302, t310, t311, t304;
|
|
|
|
// Radio bearers
|
|
typedef enum{
|
|
RB_ID_SRB0 = 0,
|
|
RB_ID_SRB1,
|
|
RB_ID_SRB2,
|
|
RB_ID_DRB1,
|
|
RB_ID_DRB2,
|
|
RB_ID_DRB3,
|
|
RB_ID_DRB4,
|
|
RB_ID_DRB5,
|
|
RB_ID_DRB6,
|
|
RB_ID_DRB7,
|
|
RB_ID_DRB8,
|
|
RB_ID_MAX
|
|
} rb_id_t;
|
|
|
|
static const std::string rb_id_str[];
|
|
|
|
std::string get_rb_name(uint32_t lcid)
|
|
{
|
|
if (lcid < RB_ID_MAX) {
|
|
return rb_id_str[lcid];
|
|
} else {
|
|
return "INVALID_RB";
|
|
}
|
|
}
|
|
|
|
// List of strongest neighbour cell
|
|
const static int NEIGHBOUR_TIMEOUT = 5;
|
|
const static int NOF_NEIGHBOUR_CELLS = 8;
|
|
std::vector<cell_t*> neighbour_cells;
|
|
cell_t *serving_cell;
|
|
void set_serving_cell(uint32_t cell_idx);
|
|
void set_serving_cell(phy_interface_rrc::phy_cell_t phy_cell);
|
|
|
|
int find_neighbour_cell(uint32_t earfcn, uint32_t pci);
|
|
bool add_neighbour_cell(uint32_t earfcn, uint32_t pci, float rsrp);
|
|
bool add_neighbour_cell(phy_interface_rrc::phy_cell_t phy_cell, float rsrp);
|
|
bool add_neighbour_cell(cell_t *cell);
|
|
void sort_neighbour_cells();
|
|
void clean_neighbours();
|
|
std::vector<cell_t*>::iterator delete_neighbour(std::vector<cell_t*>::iterator it);
|
|
void delete_neighbour(uint32_t cell_idx);
|
|
|
|
bool configure_serving_cell();
|
|
|
|
bool si_acquire(uint32_t index);
|
|
uint32_t sib_start_tti(uint32_t tti, uint32_t period, uint32_t offset, uint32_t sf);
|
|
const static int SIB_SEARCH_TIMEOUT_MS = 1000;
|
|
|
|
const static uint32_t NOF_REQUIRED_SIBS = 3; // SIB1, SIB2 and SIB3
|
|
|
|
bool initiated;
|
|
bool ho_start;
|
|
bool go_idle;
|
|
bool go_rlf;
|
|
|
|
// Measurements sub-class
|
|
class rrc_meas {
|
|
public:
|
|
void init(rrc *parent);
|
|
void reset();
|
|
bool parse_meas_config(LIBLTE_RRC_MEAS_CONFIG_STRUCT *meas_config);
|
|
void new_phy_meas(uint32_t earfcn, uint32_t pci, float rsrp, float rsrq, uint32_t tti);
|
|
void run_tti(uint32_t tti);
|
|
bool timer_expired(uint32_t timer_id);
|
|
void ho_finish();
|
|
void delete_report(uint32_t earfcn, uint32_t pci);
|
|
private:
|
|
|
|
const static int NOF_MEASUREMENTS = 3;
|
|
|
|
typedef enum {RSRP = 0, RSRQ = 1, BOTH = 2} quantity_t;
|
|
|
|
typedef struct {
|
|
uint32_t pci;
|
|
float q_offset;
|
|
} meas_cell_t;
|
|
|
|
typedef struct {
|
|
uint32_t earfcn;
|
|
float q_offset;
|
|
std::map<uint32_t, meas_cell_t> cells;
|
|
} meas_obj_t;
|
|
|
|
typedef struct {
|
|
uint32_t interval;
|
|
uint32_t max_cell;
|
|
uint32_t amount;
|
|
quantity_t trigger_quantity;
|
|
quantity_t report_quantity;
|
|
LIBLTE_RRC_EVENT_EUTRA_STRUCT event;
|
|
enum {EVENT, PERIODIC} trigger_type;
|
|
} report_cfg_t;
|
|
|
|
typedef struct {
|
|
float ms[NOF_MEASUREMENTS];
|
|
bool triggered;
|
|
bool timer_enter_triggered;
|
|
bool timer_exit_triggered;
|
|
uint32_t enter_tti;
|
|
uint32_t exit_tti;
|
|
} meas_value_t;
|
|
|
|
typedef struct {
|
|
uint32_t nof_reports_sent;
|
|
uint32_t report_id;
|
|
uint32_t object_id;
|
|
bool triggered;
|
|
uint32_t periodic_timer;
|
|
std::map<uint32_t, meas_value_t> cell_values; // Value for each PCI in this object
|
|
} meas_t;
|
|
|
|
std::map<uint32_t, meas_obj_t> objects;
|
|
std::map<uint32_t, report_cfg_t> reports_cfg;
|
|
std::map<uint32_t, meas_t> active;
|
|
|
|
rrc *parent;
|
|
srslte::log *log_h;
|
|
phy_interface_rrc *phy;
|
|
srslte::mac_interface_timers *mac_timers;
|
|
|
|
uint32_t filter_k_rsrp, filter_k_rsrq;
|
|
float filter_a[NOF_MEASUREMENTS];
|
|
|
|
meas_value_t pcell_measurement;
|
|
|
|
bool s_measure_enabled;
|
|
float s_measure_value;
|
|
|
|
void stop_reports(meas_t *m);
|
|
void stop_reports_object(uint32_t object_id);
|
|
void remove_meas_object(uint32_t object_id);
|
|
void remove_meas_report(uint32_t report_id);
|
|
void remove_meas_id(uint32_t measId);
|
|
void remove_meas_id(std::map<uint32_t, meas_t>::iterator it);
|
|
void calculate_triggers(uint32_t tti);
|
|
void update_phy();
|
|
void L3_filter(meas_value_t *value, float rsrp[NOF_MEASUREMENTS]);
|
|
bool find_earfcn_cell(uint32_t earfcn, uint32_t pci, meas_obj_t **object, int *cell_idx);
|
|
float range_to_value(quantity_t quant, uint8_t range);
|
|
uint8_t value_to_range(quantity_t quant, float value);
|
|
bool process_event(LIBLTE_RRC_EVENT_EUTRA_STRUCT *event, uint32_t tti,
|
|
bool enter_condition, bool exit_condition,
|
|
meas_t *m, meas_value_t *cell);
|
|
|
|
void generate_report(uint32_t meas_id);
|
|
};
|
|
|
|
rrc_meas measurements;
|
|
|
|
// Measurement object from phy
|
|
typedef struct {
|
|
float rsrp;
|
|
float rsrq;
|
|
uint32_t tti;
|
|
uint32_t earfcn;
|
|
uint32_t pci;
|
|
} phy_meas_t;
|
|
|
|
void process_phy_meas();
|
|
void process_new_phy_meas(phy_meas_t meas);
|
|
srslte::block_queue<phy_meas_t> phy_meas_q;
|
|
|
|
// Cell selection/reselection functions/variables
|
|
typedef struct {
|
|
float Qrxlevmin;
|
|
float Qrxlevminoffset;
|
|
float Qqualmin;
|
|
float Qqualminoffset;
|
|
float s_intrasearchP;
|
|
float q_hyst;
|
|
float threshservinglow;
|
|
} cell_resel_cfg_t;
|
|
|
|
cell_resel_cfg_t cell_resel_cfg;
|
|
|
|
float get_srxlev(float Qrxlevmeas);
|
|
float get_squal(float Qqualmeas);
|
|
|
|
typedef enum {
|
|
CHANGED_CELL = 0,
|
|
SAME_CELL = 1,
|
|
NO_CELL = 2
|
|
} cs_ret_t;
|
|
|
|
cs_ret_t cell_selection();
|
|
bool cell_selection_criteria(float rsrp, float rsrq = 0);
|
|
void cell_reselection(float rsrp, float rsrq);
|
|
|
|
phy_interface_rrc::cell_search_ret_t cell_search();
|
|
|
|
LIBLTE_RRC_PLMN_IDENTITY_STRUCT selected_plmn_id;
|
|
bool plmn_is_selected;
|
|
|
|
bool security_is_activated;
|
|
|
|
// RLC interface
|
|
void max_retx_attempted();
|
|
|
|
// Senders
|
|
void send_con_request(LIBLTE_RRC_CON_REQ_EST_CAUSE_ENUM cause);
|
|
void send_con_restablish_request(LIBLTE_RRC_CON_REEST_REQ_CAUSE_ENUM cause);
|
|
void send_con_restablish_complete();
|
|
void send_con_setup_complete(byte_buffer_t *nas_msg);
|
|
void send_ul_info_transfer(byte_buffer_t *nas_msg);
|
|
void send_security_mode_complete();
|
|
void send_rrc_con_reconfig_complete();
|
|
void send_rrc_ue_cap_info();
|
|
|
|
// Parsers
|
|
void parse_dl_ccch(byte_buffer_t *pdu);
|
|
void parse_dl_dcch(uint32_t lcid, byte_buffer_t *pdu);
|
|
void parse_dl_info_transfer(uint32_t lcid, byte_buffer_t *pdu);
|
|
|
|
// Helpers
|
|
bool con_reconfig(LIBLTE_RRC_CONNECTION_RECONFIGURATION_STRUCT *reconfig);
|
|
void con_reconfig_failed();
|
|
bool con_reconfig_ho(LIBLTE_RRC_CONNECTION_RECONFIGURATION_STRUCT *reconfig);
|
|
bool ho_prepare();
|
|
void ho_failed();
|
|
void rrc_connection_release();
|
|
void radio_link_failure();
|
|
void leave_connected();
|
|
|
|
void apply_rr_config_common_dl(LIBLTE_RRC_RR_CONFIG_COMMON_STRUCT *config);
|
|
void apply_rr_config_common_ul(LIBLTE_RRC_RR_CONFIG_COMMON_STRUCT *config);
|
|
void handle_sib1();
|
|
void handle_sib2();
|
|
void handle_sib3();
|
|
void handle_sib13();
|
|
|
|
void apply_sib2_configs(LIBLTE_RRC_SYS_INFO_BLOCK_TYPE_2_STRUCT *sib2);
|
|
void handle_con_setup(LIBLTE_RRC_CONNECTION_SETUP_STRUCT *setup);
|
|
void handle_con_reest(LIBLTE_RRC_CONNECTION_REESTABLISHMENT_STRUCT *setup);
|
|
void handle_rrc_con_reconfig(uint32_t lcid, LIBLTE_RRC_CONNECTION_RECONFIGURATION_STRUCT *reconfig);
|
|
void add_srb(LIBLTE_RRC_SRB_TO_ADD_MOD_STRUCT *srb_cnfg);
|
|
void add_drb(LIBLTE_RRC_DRB_TO_ADD_MOD_STRUCT *drb_cnfg);
|
|
void release_drb(uint8_t lcid);
|
|
bool apply_rr_config_dedicated(LIBLTE_RRC_RR_CONFIG_DEDICATED_STRUCT *cnfg);
|
|
void apply_phy_config_dedicated(LIBLTE_RRC_PHYSICAL_CONFIG_DEDICATED_STRUCT *phy_cnfg, bool apply_defaults);
|
|
void apply_mac_config_dedicated(LIBLTE_RRC_MAC_MAIN_CONFIG_STRUCT *mac_cfg, bool apply_defaults);
|
|
|
|
// Helpers for setting default values
|
|
void set_phy_default_pucch_srs();
|
|
void set_phy_default();
|
|
void set_mac_default();
|
|
void set_rrc_default();
|
|
};
|
|
|
|
} // namespace srsue
|
|
|
|
|
|
#endif // SRSUE_RRC_H
|