rrc,nr: create DU configuration manager in RRC NR class to handle the generation of SIBs and other cell-specific parameters

srsgnb/hdr/stack/mac/sched_nr_interface.h

@@ -83,8 +83,8 @@ struct sched_nr_cell_cfg_t {
   uint32_t                                               pci;
   uint32_t                                               dl_cell_nof_prb;
   uint32_t                                               ul_cell_nof_prb;
-  asn1::copy_ptr<asn1::rrc_nr::dl_cfg_common_sib_s>      dl_cfg_common;
+  asn1::rrc_nr::dl_cfg_common_sib_s                      dl_cfg_common;
-  asn1::copy_ptr<asn1::rrc_nr::ul_cfg_common_sib_s>      ul_cfg_common;
+  asn1::rrc_nr::ul_cfg_common_sib_s                      ul_cfg_common;
   srsran::optional<asn1::rrc_nr::tdd_ul_dl_cfg_common_s> tdd_ul_dl_cfg_common;
   ssb_positions_in_burst_t                               ssb_positions_in_burst;
   uint32_t                                               ssb_periodicity_ms = 0;
@@ -98,8 +98,6 @@ struct sched_nr_cell_cfg_t {
   double                               dl_center_frequency_hz;
   double                               ul_center_frequency_hz;
   double                               ssb_center_freq_hz;
-  uint32_t                             offset_to_carrier;
-  srsran_subcarrier_spacing_t          scs;
 };
 
 class sched_nr_interface

srsgnb/hdr/stack/rrc/rrc_nr.h

@@ -37,6 +37,7 @@
 namespace srsenb {
 
 class enb_bearer_manager;
+class du_config_manager;
 
 enum class rrc_nr_state_t { RRC_IDLE, RRC_INACTIVE, RRC_CONNECTED };
 
@@ -142,8 +143,8 @@ private:
   asn1::rrc_nr::sp_cell_cfg_s base_sp_cell_cfg;
 
   // vars
+  std::unique_ptr<du_config_manager> du_cfg;
   struct cell_ctxt_t {
-    asn1::rrc_nr::mib_s                                   mib;
     asn1::rrc_nr::sib1_s                                  sib1;
     asn1::rrc_nr::sys_info_ies_s::sib_type_and_info_l_    sibs;
     srsran::unique_byte_buffer_t                          mib_buffer = nullptr;

srsgnb/hdr/stack/rrc/rrc_nr_du_manager.h

@@ -0,0 +1,62 @@
+/**
+ *
+ * \section COPYRIGHT
+ *
+ * Copyright 2013-2021 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#ifndef SRSRAN_RRC_NR_DU_MANAGER_H
+#define SRSRAN_RRC_NR_DU_MANAGER_H
+
+#include "rrc_nr_config.h"
+#include "srsgnb/hdr/stack/mac/sched_nr_interface.h"
+#include "srsran/asn1/rrc_nr.h"
+
+namespace srsenb {
+
+class du_cell_config
+{
+public:
+  uint32_t cc;
+  uint32_t pci;
+
+  asn1::rrc_nr::mib_s          mib;
+  srsran::unique_byte_buffer_t packed_mib;
+
+  asn1::rrc_nr::sib1_s         sib1;
+  srsran::unique_byte_buffer_t packed_sib1;
+
+  /// SI messages (index=0 for SIB1)
+  srsran::const_byte_span packed_si_msg(uint32_t idx) { return srsran::make_span(packed_sib1); }
+  size_t                  nof_si_msgs() const { return 1; }
+};
+
+class du_config_manager
+{
+public:
+  du_config_manager(const rrc_nr_cfg_t& cfg);
+  ~du_config_manager();
+
+  int add_cell();
+
+  const du_cell_config& cell(uint32_t cc) const
+  {
+    srsran_assert(cc < cells.size(), "Unknown DU Cell Index=%d", cc);
+    return *cells[cc];
+  }
+
+private:
+  const rrc_nr_cfg_t&   cfg;
+  srslog::basic_logger& logger;
+
+  std::vector<std::unique_ptr<du_cell_config> > cells;
+};
+
+} // namespace srsenb
+
+#endif // SRSRAN_RRC_NR_DU_MANAGER_H

srsgnb/src/stack/mac/sched_nr_cfg.cc

@@ -140,15 +140,11 @@ cell_config_manager::cell_config_manager(uint32_t                   cc_,
   carrier.dl_center_frequency_hz = cell.dl_center_frequency_hz;
   carrier.ul_center_frequency_hz = cell.ul_center_frequency_hz;
   carrier.ssb_center_freq_hz     = cell.ssb_center_freq_hz;
-  carrier.offset_to_carrier      = cell.offset_to_carrier;
-  carrier.scs                    = cell.scs;
   carrier.nof_prb                = cell.dl_cell_nof_prb;
   carrier.start                  = 0; // TODO: Check
   carrier.max_mimo_layers        = cell.nof_layers;
-  if (cell.dl_cfg_common.is_present()) {
+  carrier.offset_to_carrier      = cell.dl_cfg_common.freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier;
-    carrier.offset_to_carrier = cell.dl_cfg_common->freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier;
+  carrier.scs = (srsran_subcarrier_spacing_t)cell.dl_cfg_common.init_dl_bwp.generic_params.subcarrier_spacing.value;
-    carrier.scs = (srsran_subcarrier_spacing_t)cell.dl_cfg_common->init_dl_bwp.generic_params.subcarrier_spacing.value;
-  }
 
   // TDD-UL-DL-ConfigCommon
   duplex.mode = SRSRAN_DUPLEX_MODE_FDD;

srsgnb/src/stack/mac/sched_nr_interface_utils.cc

@@ -25,9 +25,9 @@ uint32_t coreset_nof_cces(const srsran_coreset_t& coreset)
 
 void make_mib_cfg(const sched_nr_cell_cfg_t& cfg, srsran_mib_nr_t* mib)
 {
-  *mib                        = {};
+  *mib            = {};
-  mib->scs_common             = cfg.scs;
+  mib->scs_common = (srsran_subcarrier_spacing_t)cfg.dl_cfg_common.init_dl_bwp.generic_params.subcarrier_spacing.value;
-  mib->ssb_offset             = 6; // TODO
+  mib->ssb_offset = 6; // TODO
   mib->dmrs_typeA_pos         = (srsran_dmrs_sch_typeA_pos_t)cfg.dmrs_type_a_position.value;
   mib->coreset0_idx           = cfg.pdcch_cfg_sib1.ctrl_res_set_zero;
   mib->ss0_idx                = cfg.pdcch_cfg_sib1.search_space_zero;
@@ -53,12 +53,10 @@ void make_ssb_cfg(const sched_nr_cell_cfg_t& cfg, srsran::phy_cfg_nr_t::ssb_cfg_
   }
   ssb->scs     = (srsran_subcarrier_spacing_t)cfg.ssb_scs.value;
   ssb->pattern = SRSRAN_SSB_PATTERN_A;
-  if (cfg.dl_cfg_common.is_present()) {
+  if (cfg.dl_cfg_common.freq_info_dl.freq_band_list.size() > 0 and
-    if (cfg.dl_cfg_common->freq_info_dl.freq_band_list.size() > 0 and
+      cfg.dl_cfg_common.freq_info_dl.freq_band_list[0].freq_band_ind_nr_present) {
-        cfg.dl_cfg_common->freq_info_dl.freq_band_list[0].freq_band_ind_nr_present) {
+    uint32_t band = cfg.dl_cfg_common.freq_info_dl.freq_band_list[0].freq_band_ind_nr;
-      uint32_t band = cfg.dl_cfg_common->freq_info_dl.freq_band_list[0].freq_band_ind_nr;
+    ssb->pattern  = srsran::srsran_band_helper::get_ssb_pattern(band, ssb->scs);
-      ssb->pattern  = srsran::srsran_band_helper::get_ssb_pattern(band, ssb->scs);
-    }
   }
 }
 
@@ -84,10 +82,11 @@ srsran::phy_cfg_nr_t get_common_ue_phy_cfg(const sched_nr_cell_cfg_t& cfg)
   ue_phy_cfg.carrier.dl_center_frequency_hz = cfg.dl_center_frequency_hz;
   ue_phy_cfg.carrier.ul_center_frequency_hz = cfg.ul_center_frequency_hz;
   ue_phy_cfg.carrier.ssb_center_freq_hz     = cfg.ssb_center_freq_hz;
-  ue_phy_cfg.carrier.offset_to_carrier      = cfg.offset_to_carrier;
+  ue_phy_cfg.carrier.offset_to_carrier = cfg.dl_cfg_common.freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier;
-  ue_phy_cfg.carrier.scs                    = cfg.scs;
+  ue_phy_cfg.carrier.scs =
-  ue_phy_cfg.carrier.nof_prb                = cfg.dl_cell_nof_prb;
+      (srsran_subcarrier_spacing_t)cfg.dl_cfg_common.init_dl_bwp.generic_params.subcarrier_spacing.value;
-  ue_phy_cfg.carrier.max_mimo_layers        = cfg.nof_layers;
+  ue_phy_cfg.carrier.nof_prb         = cfg.dl_cell_nof_prb;
+  ue_phy_cfg.carrier.max_mimo_layers = cfg.nof_layers;
   make_ssb_cfg(cfg, &ue_phy_cfg.ssb);
 
   // remove UE-specific SearchSpaces (they will be added later via RRC)

srsgnb/src/stack/mac/test/sched_nr_cfg_generators.h

@@ -53,11 +53,16 @@ inline sched_nr_cell_cfg_t get_default_cell_cfg(const srsran::phy_cfg_nr_t& phy_
   cell_cfg.dl_center_frequency_hz = phy_cfg.carrier.dl_center_frequency_hz;
   cell_cfg.ul_center_frequency_hz = phy_cfg.carrier.ul_center_frequency_hz;
   cell_cfg.ssb_center_freq_hz     = phy_cfg.carrier.ssb_center_freq_hz;
-  cell_cfg.offset_to_carrier      = phy_cfg.carrier.offset_to_carrier;
+  cell_cfg.dl_cfg_common.freq_info_dl.scs_specific_carrier_list.resize(1);
-  cell_cfg.scs                    = phy_cfg.carrier.scs;
+  cell_cfg.dl_cfg_common.freq_info_dl.scs_specific_carrier_list[0].subcarrier_spacing =
-  cell_cfg.dl_cell_nof_prb        = phy_cfg.carrier.nof_prb;
+      (asn1::rrc_nr::subcarrier_spacing_opts::options)phy_cfg.carrier.scs;
-  cell_cfg.nof_layers             = phy_cfg.carrier.max_mimo_layers;
+  cell_cfg.dl_cfg_common.freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier =
-  cell_cfg.ssb_periodicity_ms     = phy_cfg.ssb.periodicity_ms;
+      phy_cfg.carrier.offset_to_carrier;
+  cell_cfg.dl_cfg_common.init_dl_bwp.generic_params.subcarrier_spacing =
+      (asn1::rrc_nr::subcarrier_spacing_opts::options)phy_cfg.carrier.scs;
+  cell_cfg.dl_cell_nof_prb    = phy_cfg.carrier.nof_prb;
+  cell_cfg.nof_layers         = phy_cfg.carrier.max_mimo_layers;
+  cell_cfg.ssb_periodicity_ms = phy_cfg.ssb.periodicity_ms;
   for (uint32_t i = 0; i < cell_cfg.ssb_positions_in_burst.in_one_group.length(); ++i) {
     cell_cfg.ssb_positions_in_burst.in_one_group.set(i, phy_cfg.ssb.position_in_burst[i]);
   }

srsgnb/src/stack/rrc/CMakeLists.txt

@@ -10,7 +10,7 @@ set(SOURCES rrc_nr_config_utils.cc)
 add_library(srsgnb_rrc_config_utils STATIC ${SOURCES})
 target_link_libraries(srsgnb_rrc_config_utils srsran_phy)
 
-set(SOURCES rrc_nr.cc rrc_nr_ue.cc rrc_nr_security_context.cc cell_asn1_config.cc)
+set(SOURCES rrc_nr.cc rrc_nr_ue.cc rrc_nr_security_context.cc cell_asn1_config.cc rrc_nr_du_manager.cc)
 add_library(srsgnb_rrc STATIC ${SOURCES})
 target_link_libraries(srsgnb_rrc srsgnb_rrc_config_utils)
 

srsgnb/src/stack/rrc/cell_asn1_config.cc

@@ -122,6 +122,18 @@ void set_rach_cfg_common(const srsran_prach_cfg_t& prach_cfg, asn1::rrc_nr::rach
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+void fill_tdd_ul_dl_config_common(const rrc_cell_cfg_nr_t& cfg, asn1::rrc_nr::tdd_ul_dl_cfg_common_s& tdd)
+{
+  srsran_assert(cfg.duplex_mode == SRSRAN_DUPLEX_MODE_TDD, "This function should only be called for TDD configs");
+  // TDD UL-DL config
+  tdd.ref_subcarrier_spacing.value  = (asn1::rrc_nr::subcarrier_spacing_opts::options)cfg.phy_cell.carrier.scs;
+  tdd.pattern1.dl_ul_tx_periodicity = asn1::rrc_nr::tdd_ul_dl_pattern_s::dl_ul_tx_periodicity_opts::ms10;
+  tdd.pattern1.nrof_dl_slots        = 6;
+  tdd.pattern1.nrof_dl_symbols      = 0;
+  tdd.pattern1.nrof_ul_slots        = 4;
+  tdd.pattern1.nrof_ul_symbols      = 0;
+}
+
 /// Fill list of CSI-ReportConfig with gNB config
 int fill_csi_report_from_enb_cfg(const rrc_nr_cfg_t& cfg, csi_meas_cfg_s& csi_meas_cfg)
 {
@@ -888,13 +900,7 @@ int fill_serv_cell_common_from_enb_cfg(const rrc_nr_cfg_t& cfg, uint32_t cc, ser
   if (cfg.cell_list[cc].duplex_mode == SRSRAN_DUPLEX_MODE_TDD) {
     // TDD UL-DL config
     serv_common.tdd_ul_dl_cfg_common_present = true;
-    auto& tdd_config                         = serv_common.tdd_ul_dl_cfg_common;
+    fill_tdd_ul_dl_config_common(cfg.cell_list[cc], serv_common.tdd_ul_dl_cfg_common);
-    tdd_config.ref_subcarrier_spacing        = subcarrier_spacing_e::khz15;
-    tdd_config.pattern1.dl_ul_tx_periodicity = asn1::rrc_nr::tdd_ul_dl_pattern_s::dl_ul_tx_periodicity_opts::ms10;
-    tdd_config.pattern1.nrof_dl_slots        = 6;
-    tdd_config.pattern1.nrof_dl_symbols      = 0;
-    tdd_config.pattern1.nrof_ul_slots        = 4;
-    tdd_config.pattern1.nrof_ul_symbols      = 0;
   }
 
   serv_common.ul_cfg_common_present = true;
@@ -1135,7 +1141,7 @@ void fill_dl_cfg_common_sib(const rrc_cell_cfg_nr_t& cell_cfg, dl_cfg_common_sib
   uint32_t offset_point_a_prbs       = offset_point_a_hz / prb_bw;
   cfg.freq_info_dl.offset_to_point_a = offset_point_a_prbs;
   cfg.freq_info_dl.scs_specific_carrier_list.resize(1);
-  cfg.freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier = 0;
+  cfg.freq_info_dl.scs_specific_carrier_list[0].offset_to_carrier = cell_cfg.phy_cell.carrier.offset_to_carrier;
   cfg.freq_info_dl.scs_specific_carrier_list[0].subcarrier_spacing =
       (subcarrier_spacing_opts::options)cell_cfg.phy_cell.carrier.scs;
   cfg.freq_info_dl.scs_specific_carrier_list[0].carrier_bw = cell_cfg.phy_cell.carrier.nof_prb;
@@ -1165,7 +1171,7 @@ void fill_ul_cfg_common_sib(const rrc_cell_cfg_nr_t& cell_cfg, ul_cfg_common_sib
       band_helper.get_abs_freq_point_a_arfcn(cell_cfg.phy_cell.carrier.nof_prb, cell_cfg.ul_arfcn);
 
   cfg.freq_info_ul.scs_specific_carrier_list.resize(1);
-  cfg.freq_info_ul.scs_specific_carrier_list[0].offset_to_carrier = 0;
+  cfg.freq_info_ul.scs_specific_carrier_list[0].offset_to_carrier = cell_cfg.phy_cell.carrier.offset_to_carrier;
   cfg.freq_info_ul.scs_specific_carrier_list[0].subcarrier_spacing =
       (subcarrier_spacing_opts::options)cell_cfg.phy_cell.carrier.scs;
   cfg.freq_info_ul.scs_specific_carrier_list[0].carrier_bw = cell_cfg.phy_cell.carrier.nof_prb;
@@ -1212,6 +1218,12 @@ void fill_serv_cell_cfg_common_sib(const rrc_cell_cfg_nr_t& cell_cfg, serving_ce
 
   cfg.ssb_periodicity_serving_cell.value = serving_cell_cfg_common_sib_s::ssb_periodicity_serving_cell_opts::ms20;
 
+  // TDD UL-DL config
+  if (cell_cfg.duplex_mode == SRSRAN_DUPLEX_MODE_TDD) {
+    cfg.tdd_ul_dl_cfg_common_present = true;
+    fill_tdd_ul_dl_config_common(cell_cfg, cfg.tdd_ul_dl_cfg_common);
+  }
+
   cfg.ss_pbch_block_pwr = cell_cfg.phy_cell.pdsch.rs_power;
 }
 

srsgnb/src/stack/rrc/rrc_nr.cc

@@ -14,6 +14,7 @@
 #include "srsenb/hdr/common/common_enb.h"
 #include "srsgnb/hdr/stack/rrc/cell_asn1_config.h"
 #include "srsgnb/hdr/stack/rrc/rrc_nr_config_utils.h"
+#include "srsgnb/hdr/stack/rrc/rrc_nr_du_manager.h"
 #include "srsgnb/hdr/stack/rrc/rrc_nr_ue.h"
 #include "srsgnb/src/stack/mac/test/sched_nr_cfg_generators.h"
 #include "srsran/asn1/rrc_nr_utils.h"
@@ -68,6 +69,11 @@ int rrc_nr::init(const rrc_nr_cfg_t&         cfg_,
                 cell.ssb_absolute_freq_point);
   }
 
+  du_cfg = std::make_unique<du_config_manager>(cfg);
+  for (uint32_t i = 0; i < cfg.cell_list.size(); ++i) {
+    du_cfg->add_cell();
+  }
+
   // Generate cell config structs
   cell_ctxt.reset(new cell_ctxt_t{});
   if (cfg.is_standalone) {
@@ -293,54 +299,49 @@ void rrc_nr::config_phy()
 
 void rrc_nr::config_mac()
 {
+  uint32_t cc = 0;
   // Fill MAC scheduler configuration for SIBs
   // TODO: use parsed cell NR cfg configuration
   srsran::phy_cfg_nr_default_t::reference_cfg_t ref_args{};
-  ref_args.duplex = cfg.cell_list[0].duplex_mode == SRSRAN_DUPLEX_MODE_TDD
+  ref_args.duplex = cfg.cell_list[cc].duplex_mode == SRSRAN_DUPLEX_MODE_TDD
                         ? srsran::phy_cfg_nr_default_t::reference_cfg_t::R_DUPLEX_TDD_CUSTOM_6_4
                         : srsran::phy_cfg_nr_default_t::reference_cfg_t::R_DUPLEX_FDD;
   std::vector<sched_nr_cell_cfg_t> sched_cells_cfg(1, get_default_cell_cfg(srsran::phy_cfg_nr_default_t{ref_args}));
-  sched_nr_cell_cfg_t&             cell = sched_cells_cfg[0];
+  sched_nr_cell_cfg_t&             cell = sched_cells_cfg[cc];
 
   // Derive cell config from rrc_nr_cfg_t
-  cell.bwps[0].pdcch          = cfg.cell_list[0].phy_cell.pdcch;
+  cell.bwps[0].pdcch          = cfg.cell_list[cc].phy_cell.pdcch;
-  cell.pci                    = cfg.cell_list[0].phy_cell.carrier.pci;
+  cell.pci                    = cfg.cell_list[cc].phy_cell.carrier.pci;
-  cell.nof_layers             = cfg.cell_list[0].phy_cell.carrier.max_mimo_layers;
+  cell.nof_layers             = cfg.cell_list[cc].phy_cell.carrier.max_mimo_layers;
-  cell.dl_cell_nof_prb        = cfg.cell_list[0].phy_cell.carrier.nof_prb;
+  cell.dl_cell_nof_prb        = cfg.cell_list[cc].phy_cell.carrier.nof_prb;
-  cell.ul_cell_nof_prb        = cfg.cell_list[0].phy_cell.carrier.nof_prb;
+  cell.ul_cell_nof_prb        = cfg.cell_list[cc].phy_cell.carrier.nof_prb;
-  cell.dl_center_frequency_hz = cfg.cell_list[0].phy_cell.carrier.dl_center_frequency_hz;
+  cell.dl_center_frequency_hz = cfg.cell_list[cc].phy_cell.carrier.dl_center_frequency_hz;
-  cell.ul_center_frequency_hz = cfg.cell_list[0].phy_cell.carrier.ul_center_frequency_hz;
+  cell.ul_center_frequency_hz = cfg.cell_list[cc].phy_cell.carrier.ul_center_frequency_hz;
-  cell.ssb_center_freq_hz     = cfg.cell_list[0].phy_cell.carrier.ssb_center_freq_hz;
+  cell.ssb_center_freq_hz     = cfg.cell_list[cc].phy_cell.carrier.ssb_center_freq_hz;
-  cell.offset_to_carrier      = cfg.cell_list[0].phy_cell.carrier.offset_to_carrier;
+  cell.dmrs_type_a_position   = du_cfg->cell(cc).mib.dmrs_type_a_position;
-  cell.scs                    = cfg.cell_list[0].phy_cell.carrier.scs;
+  cell.pdcch_cfg_sib1         = du_cfg->cell(cc).mib.pdcch_cfg_sib1;
+  if (du_cfg->cell(cc).sib1.serving_cell_cfg_common.tdd_ul_dl_cfg_common_present) {
+    cell.tdd_ul_dl_cfg_common.emplace(du_cfg->cell(cc).sib1.serving_cell_cfg_common.tdd_ul_dl_cfg_common);
+  }
+  cell.dl_cfg_common       = du_cfg->cell(cc).sib1.serving_cell_cfg_common.dl_cfg_common;
+  cell.ul_cfg_common       = du_cfg->cell(cc).sib1.serving_cell_cfg_common.ul_cfg_common;
+  cell.ss_pbch_block_power = du_cfg->cell(cc).sib1.serving_cell_cfg_common.ss_pbch_block_pwr;
   if (not cfg.is_standalone) {
     const serving_cell_cfg_common_s& serv_cell = base_sp_cell_cfg.recfg_with_sync.sp_cell_cfg_common;
     // Derive cell config from ASN1
     bool valid_cfg = srsran::make_pdsch_cfg_from_serv_cell(base_sp_cell_cfg.sp_cell_cfg_ded, &cell.bwps[0].pdsch);
     srsran_assert(valid_cfg, "Invalid NR cell configuration.");
-    if (serv_cell.tdd_ul_dl_cfg_common_present) {
-      cell.tdd_ul_dl_cfg_common.emplace(serv_cell.tdd_ul_dl_cfg_common);
-    }
     cell.ssb_positions_in_burst.in_one_group.set(0, true);
-    cell.ssb_periodicity_ms  = serv_cell.ssb_periodicity_serving_cell.to_number();
+    cell.ssb_periodicity_ms = serv_cell.ssb_periodicity_serving_cell.to_number();
-    cell.ssb_scs             = serv_cell.ssb_subcarrier_spacing;
+    cell.ssb_scs            = serv_cell.ssb_subcarrier_spacing;
-    cell.ss_pbch_block_power = serv_cell.ss_pbch_block_pwr;
   } else {
     const serving_cell_cfg_common_sib_s& serv_cell = cell_ctxt->sib1.serving_cell_cfg_common;
     cell.bwps[0].pdsch.p_zp_csi_rs_set             = {};
     bzero(cell.bwps[0].pdsch.nzp_csi_rs_sets, sizeof(cell.bwps[0].pdsch.nzp_csi_rs_sets));
-    cell.dl_cfg_common.reset(new dl_cfg_common_sib_s{serv_cell.dl_cfg_common});
-    cell.ul_cfg_common.reset(new ul_cfg_common_sib_s{serv_cell.ul_cfg_common});
-    if (serv_cell.tdd_ul_dl_cfg_common_present) {
-      cell.tdd_ul_dl_cfg_common.emplace(serv_cell.tdd_ul_dl_cfg_common);
-    }
     cell.ssb_positions_in_burst = serv_cell.ssb_positions_in_burst;
     cell.ssb_periodicity_ms     = serv_cell.ssb_periodicity_serving_cell.to_number();
     cell.ssb_scs.value          = (subcarrier_spacing_e::options)cfg.cell_list[0].phy_cell.carrier.scs;
-    cell.ss_pbch_block_power    = serv_cell.ss_pbch_block_pwr;
   }
-  cell.dmrs_type_a_position = cell_ctxt->mib.dmrs_type_a_position;
-  cell.pdcch_cfg_sib1       = cell_ctxt->mib.pdcch_cfg_sib1;
 
   // Set SIB1 and SI messages
   cell.sibs.resize(cell_ctxt->sib_buffer.size());
@@ -364,26 +365,6 @@ void rrc_nr::config_mac()
 
 int32_t rrc_nr::generate_sibs()
 {
-  // MIB packing
-  fill_mib_from_enb_cfg(cfg.cell_list[0], cell_ctxt->mib);
-  bcch_bch_msg_s mib_msg;
-  mib_msg.msg.set_mib() = cell_ctxt->mib;
-  {
-    srsran::unique_byte_buffer_t mib_buf = srsran::make_byte_buffer();
-    if (mib_buf == nullptr) {
-      logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
-      return SRSRAN_ERROR;
-    }
-    asn1::bit_ref bref(mib_buf->msg, mib_buf->get_tailroom());
-    if (mib_msg.pack(bref) != asn1::SRSASN_SUCCESS) {
-      logger.error("Couldn't pack mib msg");
-      return SRSRAN_ERROR;
-    }
-    mib_buf->N_bytes = bref.distance_bytes();
-    logger.debug(mib_buf->msg, mib_buf->N_bytes, "MIB payload (%d B)", mib_buf->N_bytes);
-    cell_ctxt->mib_buffer = std::move(mib_buf);
-  }
-
   if (not cfg.is_standalone) {
     return SRSRAN_SUCCESS;
   }

srsgnb/src/stack/rrc/rrc_nr_du_manager.cc

@@ -0,0 +1,96 @@
+/**
+ *
+ * \section COPYRIGHT
+ *
+ * Copyright 2013-2021 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "srsgnb/hdr/stack/rrc/rrc_nr_du_manager.h"
+#include "srsgnb/hdr/stack/rrc/cell_asn1_config.h"
+#include "srsran/common/string_helpers.h"
+
+using namespace asn1::rrc_nr;
+
+namespace srsenb {
+
+du_config_manager::du_config_manager(const rrc_nr_cfg_t& cfg_) : cfg(cfg_), logger(srslog::fetch_basic_logger("RRC-NR"))
+{}
+
+du_config_manager::~du_config_manager() {}
+
+int du_config_manager::add_cell()
+{
+  // add cell
+  std::unique_ptr<du_cell_config> obj  = std::make_unique<du_cell_config>();
+  du_cell_config&                 cell = *obj;
+  cell.cc                              = cells.size();
+
+  // Fill general cell params
+  cell.pci = cfg.cell_list[cell.cc].phy_cell.carrier.pci;
+
+  // fill MIB ASN.1
+  if (fill_mib_from_enb_cfg(cfg.cell_list[cell.cc], cell.mib) != SRSRAN_SUCCESS) {
+    return SRSRAN_ERROR;
+  }
+
+  // Pack MIB
+  cell.packed_mib = srsran::make_byte_buffer();
+  if (cell.packed_mib == nullptr) {
+    logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
+    return SRSRAN_ERROR;
+  }
+  {
+    asn1::bit_ref  bref(cell.packed_mib->msg, cell.packed_mib->get_tailroom());
+    bcch_bch_msg_s bch_msg;
+    bch_msg.msg.set_mib() = cell.mib;
+    if (bch_msg.pack(bref) != asn1::SRSASN_SUCCESS) {
+      logger.error("Couldn't pack mib msg");
+      return SRSRAN_ERROR;
+    }
+    cell.packed_mib->N_bytes = bref.distance_bytes();
+  }
+  logger.info(
+      cell.packed_mib->data(), cell.packed_mib->size(), "BCCH-BCH Message (with MIB) (%d B)", cell.packed_mib->size());
+  asn1::json_writer js;
+  cell.mib.to_json(js);
+  logger.info("MIB content: %s", js.to_string().c_str());
+
+  // fill SIB1 ASN.1
+  if (fill_sib1_from_enb_cfg(cfg, cell.cc, cell.sib1) != SRSRAN_SUCCESS) {
+    logger.error("Couldn't generate SIB1");
+    return SRSRAN_ERROR;
+  }
+
+  // Pack SIB1
+  cell.packed_sib1 = srsran::make_byte_buffer();
+  if (cell.packed_sib1 == nullptr) {
+    logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
+    return SRSRAN_ERROR;
+  }
+  {
+    asn1::bit_ref     bref(cell.packed_sib1->msg, cell.packed_sib1->get_tailroom());
+    bcch_dl_sch_msg_s bcch_msg;
+    bcch_msg.msg.set_c1().set_sib_type1() = cell.sib1;
+    if (bcch_msg.pack(bref) != asn1::SRSASN_SUCCESS) {
+      logger.error("Couldn't pack SIB1 msg");
+      return SRSRAN_ERROR;
+    }
+    cell.packed_sib1->N_bytes = bref.distance_bytes();
+  }
+  logger.info(cell.packed_sib1->data(),
+              cell.packed_sib1->size(),
+              "BCCH-DL-SCH-Message (with SIB1) (%d B)",
+              cell.packed_sib1->size());
+  cell.sib1.to_json(js);
+  logger.info("SIB1 content: %s", js.to_string().c_str());
+
+  cells.push_back(std::move(obj));
+  return SRSRAN_SUCCESS;
+}
+
+} // namespace srsenb