5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixed group extensions, removed extra presence flag for copy_ptr<T> types as it was just a source of bugs.

Browse Source
master
Francisco Paisana 5 years ago committed by Andre Puschmann
parent bf35f83a5e
commit 116dc0a57b
9 changed files with 4428 additions and 6098 deletions
Show Stats Download Patch File Download Diff File

102
lib/include/srslte/asn1/asn1_utils.h
Unescape Escape View File

@ -23,6 +23,7 @@
#define SRSASN_COMMON_UTILS_H #define SRSASN_COMMON_UTILS_H
#include <algorithm> #include <algorithm>
#include <array>
#include <cmath> #include <cmath>
#include <cstring> #include <cstring>
#include <sstream> #include <sstream>
@ -80,8 +81,13 @@ ValOrError unpack_bits(uint8_t*& ptr, uint8_t& offset, uint8_t* max_ptr, uint32_
class bit_ref class bit_ref
{ {
public: public:
bit_ref(); bit_ref() = default;
bit_ref(uint8_t* start_ptr_, uint32_t max_size_); bit_ref(uint8_t* start_ptr_, uint32_t max_size_) :
ptr(start_ptr_),
start_ptr(start_ptr_),
max_ptr(max_size_ + start_ptr_)
{
}
int distance(const bit_ref& other) const; int distance(const bit_ref& other) const;
int distance(uint8_t* ref_ptr) const; int distance(uint8_t* ref_ptr) const;
@ -102,10 +108,10 @@ public:
void set(uint8_t* start_ptr_, uint32_t max_size_); void set(uint8_t* start_ptr_, uint32_t max_size_);
private: private:
uint8_t* ptr; uint8_t* ptr = nullptr;
uint8_t offset; uint8_t offset = 0;
uint8_t* start_ptr; uint8_t* start_ptr = nullptr;
uint8_t* max_ptr; uint8_t* max_ptr = nullptr;
}; };
/********************* /*********************
@ -116,7 +122,7 @@ class dyn_array
{ {
public: public:
typedef T item_type; typedef T item_type;
dyn_array() : data_(NULL), size_(0), cap_(0) {} dyn_array() = default;
dyn_array(uint32_t new_size) : size_(new_size), cap_(new_size) { data_ = new T[size_]; } dyn_array(uint32_t new_size) : size_(new_size), cap_(new_size) { data_ = new T[size_]; }
dyn_array(const dyn_array<T>& other) dyn_array(const dyn_array<T>& other)
{ {
@ -183,8 +189,9 @@ public:
const T* data() const { return &data_[0]; } const T* data() const { return &data_[0]; }
private: private:
T* data_; T* data_ = nullptr;
uint32_t size_, cap_; uint32_t size_ = 0;
uint32_t cap_ = 0;
}; };
template <class T, uint32_t MAX_N> template <class T, uint32_t MAX_N>
@ -219,24 +226,6 @@ private:
uint32_t current_size; uint32_t current_size;
}; };
template <class T, uint32_t N>
class fixed_array
{
public:
typedef T item_type;
static uint32_t size() { return N; }
T& operator[](uint32_t idx) { return data_[idx]; }
const T& operator[](uint32_t idx) const { return data_[idx]; }
bool operator==(const fixed_array<T, N>& other) const { return std::equal(data_, data_ + size(), other.data_); }
T& back() { return data_[size() - 1]; }
const T& back() const { return data_[size() - 1]; }
T* data() { return &data_[0]; }
const T* data() const { return &data_[0]; }
private:
T data_[N];
};
/********************* /*********************
ext packing ext packing
*********************/ *********************/
@ -341,22 +330,21 @@ template <class IntType>
SRSASN_CODE unpack_unalign_integer(IntType& n, bit_ref& bref, IntType lb, IntType ub); SRSASN_CODE unpack_unalign_integer(IntType& n, bit_ref& bref, IntType lb, IntType ub);
template <class IntType> template <class IntType>
struct UnalignedIntegerPacker { struct UnalignedIntegerPacker {
UnalignedIntegerPacker(IntType, IntType); UnalignedIntegerPacker(IntType lb_, IntType ub_) : lb(lb_), ub(ub_) {}
IntType lb; const IntType lb;
IntType ub; const IntType ub;
SRSASN_CODE pack(bit_ref& bref, IntType n) const; SRSASN_CODE pack(bit_ref& bref, IntType n) const;
SRSASN_CODE unpack(IntType& n, bit_ref& bref) const; SRSASN_CODE unpack(IntType& n, bit_ref& bref) const;
}; };
template <class IntType, IntType lb, IntType ub> template <class IntType, IntType lb, IntType ub>
struct unaligned_integer { struct unaligned_integer {
IntType value; IntType value;
const UnalignedIntegerPacker<IntType> packer; unaligned_integer() = default;
unaligned_integer() : packer(lb, ub) {} unaligned_integer(IntType value_) : value(value_) {}
unaligned_integer(IntType value_) : value(value_), packer(lb, ub) {}
operator IntType() { return value; } operator IntType() { return value; }
SRSASN_CODE pack(bit_ref& bref) const { return packer.pack(bref, value); } SRSASN_CODE pack(bit_ref& bref) const { return pack_unalign_integer(bref, value, lb, ub); }
SRSASN_CODE unpack(bit_ref& bref) { return packer.unpack(value, bref); } SRSASN_CODE unpack(bit_ref& bref) { return unpack_unalign_integer(value, bref, lb, ub); }
}; };
template <class IntType> template <class IntType>
@ -486,7 +474,7 @@ public:
SRSASN_CODE unpack(bit_ref& bref); SRSASN_CODE unpack(bit_ref& bref);
private: private:
fixed_array<uint8_t, N> octets_; std::array<uint8_t, N> octets_;
}; };
template <uint32_t N> template <uint32_t N>
@ -520,7 +508,7 @@ SRSASN_CODE fixed_octstring<N>::unpack(bit_ref& bref)
class dyn_octstring class dyn_octstring
{ {
public: public:
dyn_octstring() {} dyn_octstring() = default;
dyn_octstring(uint32_t new_size) : octets_(new_size) {} dyn_octstring(uint32_t new_size) : octets_(new_size) {}
const uint8_t& operator[](uint32_t idx) const { return octets_[idx]; } const uint8_t& operator[](uint32_t idx) const { return octets_[idx]; }
@ -621,7 +609,7 @@ public:
SRSASN_CODE unpack(bit_ref& bref, bool& ext) { return unpack_fixed_bitstring(data(), ext, bref, N); } SRSASN_CODE unpack(bit_ref& bref, bool& ext) { return unpack_fixed_bitstring(data(), ext, bref, N); }
private: private:
fixed_array<uint8_t, (uint32_t)((N + 7) / 8)> octets_; // ceil(N/8.0) std::array<uint8_t, (uint32_t)((N + 7) / 8)> octets_; // ceil(N/8.0)
}; };
/********************* /*********************
@ -874,16 +862,15 @@ template <class T>
class copy_ptr class copy_ptr
{ {
public: public:
copy_ptr() : ptr(NULL) {} explicit copy_ptr(T* ptr_ = nullptr) :
explicit copy_ptr(T* ptr_) :
ptr(ptr_) {} // it takes hold of the pointer (including destruction). You should use make_copy_ptr() in most cases ptr(ptr_) {} // it takes hold of the pointer (including destruction). You should use make_copy_ptr() in most cases
// instead of this ctor // instead of this ctor
copy_ptr(const copy_ptr<T>& other) { ptr = other.make_obj_(); } // it allocates new memory for the new object copy_ptr(const copy_ptr<T>& other) { ptr = (other.ptr == nullptr) ? nullptr : new T(*other.ptr); }
~copy_ptr() { destroy_(); } ~copy_ptr() { destroy_(); }
copy_ptr<T>& operator=(const copy_ptr<T>& other) copy_ptr<T>& operator=(const copy_ptr<T>& other)
{ {
if (this != &other) { if (this != &other) {
acquire(other.make_obj_()); reset((other.ptr == nullptr) ? nullptr : new T(*other.ptr));
} }
return *this; return *this;
} }
@ -897,15 +884,23 @@ public:
T* release() T* release()
{ {
T* ret = ptr; T* ret = ptr;
ptr = NULL; ptr = nullptr;
return ret; return ret;
} }
void acquire(T* ptr_) void reset(T* ptr_ = nullptr)
{ {
destroy_(); destroy_();
ptr = ptr_; ptr = ptr_;
} }
void reset() { acquire(NULL); } void set_present(bool flag = true)
{
if (flag) {
reset(new T());
} else {
reset();
}
}
bool is_present() const { return get() != nullptr; }
private: private:
void destroy_() void destroy_()
@ -914,7 +909,6 @@ private:
delete ptr; delete ptr;
} }
} }
T* make_obj_() const { return (ptr == NULL) ? NULL : new T(*ptr); }
T* ptr; T* ptr;
}; };
@ -931,19 +925,13 @@ copy_ptr<T> make_copy_ptr(const T& t)
class ext_groups_header class ext_groups_header
{ {
public: public:
ext_groups_header(uint32_t max_nof_groups, uint32_t nof_nogroups_ = 0); ext_groups_header();
bool& operator[](uint32_t idx); bool& operator[](uint32_t idx);
SRSASN_CODE pack_nof_groups(bit_ref& bref) const;
SRSASN_CODE pack_group_flags(bit_ref& bref) const;
SRSASN_CODE pack(bit_ref& bref) const; SRSASN_CODE pack(bit_ref& bref) const;
SRSASN_CODE unpack_nof_groups(bit_ref& bref);
SRSASN_CODE unpack_group_flags(bit_ref& bref);
SRSASN_CODE unpack(bit_ref& bref); SRSASN_CODE unpack(bit_ref& bref);
private: private:
mutable uint32_t nof_groups;
const uint32_t nof_nogroups;
bounded_array<bool, 20> groups; bounded_array<bool, 20> groups;
}; };

592
lib/include/srslte/asn1/rrc_asn1.h
View File

File diff suppressed because it is too large Load Diff

5
lib/include/srslte/interfaces/ue_interfaces.h
Unescape Escape View File

@ -565,9 +565,8 @@ public:
phr_cfg.db_pathloss_change = cfg.phr_cfg.setup().dl_pathloss_change.to_number(); phr_cfg.db_pathloss_change = cfg.phr_cfg.setup().dl_pathloss_change.to_number();
} }
} }
if (cfg.mac_main_cfg_v1020_present) { if (cfg.mac_main_cfg_v1020.is_present()) {
typedef asn1::rrc::mac_main_cfg_s::mac_main_cfg_v1020_s_ mac_main_cfg_v1020_t; asn1::rrc::mac_main_cfg_s::mac_main_cfg_v1020_s_* mac_main_cfg_v1020 = cfg.mac_main_cfg_v1020.get();
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; phr_cfg.extended = mac_main_cfg_v1020->extended_phr_r10_present;
} }
if (cfg.ul_sch_cfg_present) { if (cfg.ul_sch_cfg_present) {

92
lib/src/asn1/asn1_utils.cc
Unescape Escape View File

@ -83,16 +83,6 @@ void log_error_code(SRSASN_CODE code, const char* filename, int line)
bit_ref bit_ref
*********************/ *********************/
bit_ref::bit_ref() : ptr(NULL), offset(0), start_ptr(NULL), max_ptr(NULL) {}
bit_ref::bit_ref(uint8_t* start_ptr_, uint32_t max_size_) :
ptr(start_ptr_),
offset(0),
start_ptr(start_ptr_),
max_ptr(max_size_ + start_ptr_)
{
}
int bit_ref::distance(const bit_ref& other) const int bit_ref::distance(const bit_ref& other) const
{ {
return ((int)offset - (int)other.offset) + 8 * ((int)(ptr - other.ptr)); return ((int)offset - (int)other.offset) + 8 * ((int)(ptr - other.ptr));
@ -370,10 +360,6 @@ template SRSASN_CODE unpack_unalign_integer<uint16_t>(uint16_t& n, bit_ref& bref
template SRSASN_CODE unpack_unalign_integer<uint32_t>(uint32_t& n, bit_ref& bref, uint32_t lb, uint32_t ub); template SRSASN_CODE unpack_unalign_integer<uint32_t>(uint32_t& n, bit_ref& bref, uint32_t lb, uint32_t ub);
template SRSASN_CODE unpack_unalign_integer<uint64_t>(uint64_t& n, bit_ref& bref, uint64_t lb, uint64_t ub); template SRSASN_CODE unpack_unalign_integer<uint64_t>(uint64_t& n, bit_ref& bref, uint64_t lb, uint64_t ub);
template <class IntType>
UnalignedIntegerPacker<IntType>::UnalignedIntegerPacker(IntType lb_, IntType ub_) : lb(lb_), ub(ub_)
{
}
template <class IntType> template <class IntType>
SRSASN_CODE UnalignedIntegerPacker<IntType>::pack(bit_ref& bref, IntType n) const SRSASN_CODE UnalignedIntegerPacker<IntType>::pack(bit_ref& bref, IntType n) const
{ {
@ -921,86 +907,56 @@ void log_invalid_choice_id(uint32_t val, const char* choice_type)
ext group ext group
*********************/ *********************/
ext_groups_header::ext_groups_header(uint32_t max_nof_groups, uint32_t nof_nogroups_) : nof_nogroups(nof_nogroups_) ext_groups_header::ext_groups_header()
{ {
if (max_nof_groups > 20) { groups.resize(20);
srsasn_log_print(LOG_LEVEL_ERROR, "increase the size of ext group packer/unpacker\n"); std::fill(groups.data(), groups.data() + groups.size(), false);
}
groups.resize(max_nof_groups);
for (uint32_t i = 0; i < groups.size(); ++i) {
groups[i] = false;
}
nof_groups = groups.size() + 1; // unset
} }
bool& ext_groups_header::operator[](uint32_t idx) bool& ext_groups_header::operator[](uint32_t idx)
{ {
if (idx >= groups.size()) {
uint32_t prev_size = groups.size();
groups.resize(idx + 1);
std::fill(&groups[prev_size], &groups[groups.size()], false);
}
return groups[idx]; return groups[idx];
} }
SRSASN_CODE ext_groups_header::pack_nof_groups(bit_ref& bref) const SRSASN_CODE ext_groups_header::pack(bit_ref& bref) const
{ {
nof_groups = 0; // pack number of groups
for (uint32_t i = 0; i < groups.size(); ++i) { int32_t i = groups.size() - 1;
for (; i >= 0; --i) {
if (groups[i]) { if (groups[i]) {
nof_groups = i + 1; break;
} }
} }
if (nof_groups > groups.size()) { uint32_t nof_groups = (uint32_t)i + 1u;
srsasn_log_print(LOG_LEVEL_ERROR, "Exceeded maximum number of groups (%d>%d)\n", nof_groups, groups.size()); HANDLE_CODE(pack_norm_small_integer(bref, nof_groups - 1));
return SRSASN_ERROR_ENCODE_FAIL;
}
HANDLE_CODE(pack_norm_small_integer(bref, nof_groups + nof_nogroups - 1));
return SRSASN_SUCCESS;
}
SRSASN_CODE ext_groups_header::pack_group_flags(bit_ref& bref) const // pack each group presence flag
{ for (uint32_t j = 0; j < nof_groups; ++j) {
if (nof_groups > groups.size()) { HANDLE_CODE(bref.pack(groups[j], 1));
srsasn_log_print(LOG_LEVEL_ERROR, "Exceeded maximum number of groups (%d>%d)\n", nof_groups, groups.size());
return SRSASN_ERROR_ENCODE_FAIL;
}
for (uint32_t i = 0; i < nof_groups; ++i) {
HANDLE_CODE(bref.pack(groups[i], 1));
} }
return SRSASN_SUCCESS; return SRSASN_SUCCESS;
} }
SRSASN_CODE ext_groups_header::pack(bit_ref& bref) const SRSASN_CODE ext_groups_header::unpack(bit_ref& bref)
{
HANDLE_CODE(pack_nof_groups(bref));
return pack_group_flags(bref);
}
SRSASN_CODE ext_groups_header::unpack_nof_groups(bit_ref& bref)
{ {
// unpack nof of ext groups
uint32_t nof_groups;
HANDLE_CODE(unpack_norm_small_integer(nof_groups, bref)); HANDLE_CODE(unpack_norm_small_integer(nof_groups, bref));
nof_groups += 1 - nof_nogroups; nof_groups += 1;
if (nof_groups > groups.size()) { groups.resize(nof_groups);
srsasn_log_print(LOG_LEVEL_ERROR, "Exceeded maximum number of groups (%d>%d)\n", nof_groups, groups.size());
return SRSASN_ERROR_DECODE_FAIL;
}
return SRSASN_SUCCESS;
}
SRSASN_CODE ext_groups_header::unpack_group_flags(bit_ref& bref) // unpack each group presence flag
{
if (nof_groups > groups.size()) {
srsasn_log_print(LOG_LEVEL_ERROR, "Exceeded maximum number of groups (%d>%d)\n", nof_groups, groups.size());
return SRSASN_ERROR_DECODE_FAIL;
}
for (uint32_t i = 0; i < nof_groups; ++i) { for (uint32_t i = 0; i < nof_groups; ++i) {
HANDLE_CODE(bref.unpack(groups[i], 1)); HANDLE_CODE(bref.unpack(groups[i], 1));
} }
return SRSASN_SUCCESS; return SRSASN_SUCCESS;
} }
SRSASN_CODE ext_groups_header::unpack(bit_ref& bref)
{
HANDLE_CODE(unpack_nof_groups(bref));
return unpack_group_flags(bref);
}
/********************* /*********************
Open Field Open Field
*********************/ *********************/

9708
lib/src/asn1/rrc_asn1.cc
View File

File diff suppressed because it is too large Load Diff

2
srsenb/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -1546,7 +1546,7 @@ void rrc::ue::send_connection_setup(bool is_setup)
rr_cfg->drb_to_add_mod_list_present = false; rr_cfg->drb_to_add_mod_list_present = false;
rr_cfg->drb_to_release_list_present = false; rr_cfg->drb_to_release_list_present = false;
rr_cfg->rlf_timers_and_consts_r9_present = false; rr_cfg->rlf_timers_and_consts_r9.set_present(false);
rr_cfg->sps_cfg_present = false; rr_cfg->sps_cfg_present = false;
// rr_cfg->rlf_timers_and_constants_present = false; // rr_cfg->rlf_timers_and_constants_present = false;

8
srsue/src/phy/cc_worker.cc
Unescape Escape View File

@ -979,7 +979,7 @@ srslte_cqi_report_mode_t cc_worker::aperiodic_mode(cqi_report_mode_aperiodic_e m
void cc_worker::parse_antenna_info(phys_cfg_ded_s* dedicated) void cc_worker::parse_antenna_info(phys_cfg_ded_s* dedicated)
{ {
if (dedicated->ant_info_r10_present) { if (dedicated->ant_info_r10.is_present()) {
// Parse Release 10 // Parse Release 10
ant_info_ded_r10_s::tx_mode_r10_e_::options tx_mode = ant_info_ded_r10_s::tx_mode_r10_e_::options tx_mode =
dedicated->ant_info_r10->explicit_value_r10().tx_mode_r10.value; dedicated->ant_info_r10->explicit_value_r10().tx_mode_r10.value;
@ -1057,7 +1057,7 @@ void cc_worker::parse_pucch_config(phy_interface_rrc_lte::phy_cfg_t* phy_cfg)
ue_ul_cfg.ul_cfg.pucch.tdd_ack_bundle = false; ue_ul_cfg.ul_cfg.pucch.tdd_ack_bundle = false;
} }
if (dedicated->pucch_cfg_ded_v1020_present) { if (dedicated->pucch_cfg_ded_v1020.is_present()) {
pucch_cfg_ded_v1020_s* pucch_cfg_ded = dedicated->pucch_cfg_ded_v1020.get(); pucch_cfg_ded_v1020_s* pucch_cfg_ded = dedicated->pucch_cfg_ded_v1020.get();
if (pucch_cfg_ded->pucch_format_r10_present) { if (pucch_cfg_ded->pucch_format_r10_present) {
@ -1230,7 +1230,7 @@ void cc_worker::set_pcell_config(phy_interface_rrc_lte::phy_cfg_t* phy_cfg)
ue_dl_cfg.cfg.cqi_report.aperiodic_configured = true; ue_dl_cfg.cfg.cqi_report.aperiodic_configured = true;
ue_dl_cfg.cfg.cqi_report.aperiodic_mode = aperiodic_mode(dedicated->cqi_report_cfg.cqi_report_mode_aperiodic); ue_dl_cfg.cfg.cqi_report.aperiodic_mode = aperiodic_mode(dedicated->cqi_report_cfg.cqi_report_mode_aperiodic);
} }
if (dedicated->cqi_report_cfg_pcell_v1250_present) { if (dedicated->cqi_report_cfg_pcell_v1250.is_present()) {
auto cqi_report_cfg_pcell_v1250 = dedicated->cqi_report_cfg_pcell_v1250.get(); auto cqi_report_cfg_pcell_v1250 = dedicated->cqi_report_cfg_pcell_v1250.get();
if (cqi_report_cfg_pcell_v1250->alt_cqi_table_r12_present) { if (cqi_report_cfg_pcell_v1250->alt_cqi_table_r12_present) {
ue_dl_cfg.pdsch_use_tbs_index_alt = true; ue_dl_cfg.pdsch_use_tbs_index_alt = true;
@ -1392,7 +1392,7 @@ void cc_worker::set_scell_config(asn1::rrc::scell_to_add_mod_r10_s* phy_cfg)
} }
} }
if (phys_cfg_ded_scell_r10->cqi_report_cfg_scell_v1250_present) { if (phys_cfg_ded_scell_r10->cqi_report_cfg_scell_v1250.is_present()) {
auto cqi_report_cfg_scell = phys_cfg_ded_scell_r10->cqi_report_cfg_scell_v1250.get(); auto cqi_report_cfg_scell = phys_cfg_ded_scell_r10->cqi_report_cfg_scell_v1250.get();
// Enable/disable PDSCH 256QAM // Enable/disable PDSCH 256QAM

2
srsue/src/phy/phy.cc
Unescape Escape View File

@ -461,7 +461,7 @@ void phy::set_config_scell(asn1::rrc::scell_to_add_mod_r10_s* scell_config)
// Parse radio resource // Parse radio resource
if (scell_config->rr_cfg_common_scell_r10_present) { if (scell_config->rr_cfg_common_scell_r10_present) {
rr_cfg_common_scell_r10_s* rr_cfg = &scell_config->rr_cfg_common_scell_r10; rr_cfg_common_scell_r10_s* rr_cfg = &scell_config->rr_cfg_common_scell_r10;
cell.frame_type = (rr_cfg->tdd_cfg_v1130_present) ? SRSLTE_TDD : SRSLTE_FDD; cell.frame_type = (rr_cfg->tdd_cfg_v1130.is_present()) ? SRSLTE_TDD : SRSLTE_FDD;
cell.nof_prb = rr_cfg->non_ul_cfg_r10.dl_bw_r10.to_number(); cell.nof_prb = rr_cfg->non_ul_cfg_r10.dl_bw_r10.to_number();
cell.nof_ports = rr_cfg->non_ul_cfg_r10.ant_info_common_r10.ant_ports_count.to_number(); cell.nof_ports = rr_cfg->non_ul_cfg_r10.ant_info_common_r10.ant_ports_count.to_number();
cell.phich_length = (srslte_phich_length_t)rr_cfg->non_ul_cfg_r10.phich_cfg_r10.phich_dur.value; cell.phich_length = (srslte_phich_length_t)rr_cfg->non_ul_cfg_r10.phich_cfg_r10.phich_dur.value;

15
srsue/src/stack/rrc/rrc.cc
Unescape Escape View File

@ -1632,7 +1632,7 @@ void rrc::handle_sib2()
} else if (args.release >= 12 && sib2->rr_cfg_common.pusch_cfg_common.pusch_cfg_basic.enable64_qam) { } else if (args.release >= 12 && sib2->rr_cfg_common.pusch_cfg_common.pusch_cfg_basic.enable64_qam) {
if (args.ue_category_ul == 5 || args.ue_category_ul == 13) { if (args.ue_category_ul == 5 || args.ue_category_ul == 13) {
// ASN1 Generator simplifies enable64QAM-v1270 because it is an enumeration that is always true // ASN1 Generator simplifies enable64QAM-v1270 because it is an enumeration that is always true
current_phy_cfg.common.rrc_enable_64qam = sib2->rr_cfg_common.pusch_cfg_common_v1270_present; current_phy_cfg.common.rrc_enable_64qam = sib2->rr_cfg_common.pusch_cfg_common_v1270.is_present();
} else { } else {
current_phy_cfg.common.rrc_enable_64qam = false; current_phy_cfg.common.rrc_enable_64qam = false;
} }
@ -2497,15 +2497,8 @@ void rrc::apply_phy_config_dedicated(const phys_cfg_ded_s& phy_cnfg)
current_cfg->pucch_cfg_ded = phy_cnfg.pucch_cfg_ded; current_cfg->pucch_cfg_ded = phy_cnfg.pucch_cfg_ded;
} }
if (phy_cnfg.cqi_report_cfg_pcell_v1250_present) { current_cfg->cqi_report_cfg_pcell_v1250 = phy_cnfg.cqi_report_cfg_pcell_v1250;
current_cfg->cqi_report_cfg_pcell_v1250_present = true; current_cfg->pucch_cfg_ded_v1020 = phy_cnfg.pucch_cfg_ded_v1020;
current_cfg->cqi_report_cfg_pcell_v1250 = phy_cnfg.cqi_report_cfg_pcell_v1250;
}
if (phy_cnfg.pucch_cfg_ded_v1020_present) {
current_cfg->pucch_cfg_ded_v1020_present = true;
current_cfg->pucch_cfg_ded_v1020 = phy_cnfg.pucch_cfg_ded_v1020;
}
if (phy_cnfg.pusch_cfg_ded_present) { if (phy_cnfg.pusch_cfg_ded_present) {
current_cfg->pusch_cfg_ded_present = true; current_cfg->pusch_cfg_ded_present = true;
@ -2632,7 +2625,7 @@ bool rrc::apply_rr_config_dedicated(rr_cfg_ded_s* cnfg)
if (cnfg->sps_cfg_present) { if (cnfg->sps_cfg_present) {
//TODO //TODO
} }
if (cnfg->rlf_timers_and_consts_r9_present and cnfg->rlf_timers_and_consts_r9->type() == setup_e::setup) { if (cnfg->rlf_timers_and_consts_r9.is_present() and cnfg->rlf_timers_and_consts_r9->type() == setup_e::setup) {
mac_timers->timer_get(t301)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t301_r9.to_number()); mac_timers->timer_get(t301)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t301_r9.to_number());
mac_timers->timer_get(t310)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t310_r9.to_number()); mac_timers->timer_get(t310)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t310_r9.to_number());
mac_timers->timer_get(t311)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t311_r9.to_number()); mac_timers->timer_get(t311)->set(this, cnfg->rlf_timers_and_consts_r9->setup().t311_r9.to_number());

Write Preview
Loading…
Cancel
Save