du: prevent getting band from arfcn when band is given

Signed-off-by: Carlo Galiotto <[email protected]>

Author: carlo-gal

apps/units/flexible_du/du_high/du_high_config_validator.cpp

@@ -195,10 +195,9 @@ static bool validate_srb_unit_config(const std::map<srb_id_t, du_high_unit_srb_c
   return true;
 }
 
-static bool validate_pdcch_unit_config(const du_high_unit_base_cell_config base_cell)
+static bool validate_pdcch_unit_config(const du_high_unit_base_cell_config& base_cell)
 {
-  const auto band =
-      base_cell.band.has_value() ? *base_cell.band : band_helper::get_band_from_dl_arfcn(base_cell.dl_f_ref_arfcn);
+  const auto     band = base_cell.band.value_or(band_helper::get_band_from_dl_arfcn(base_cell.dl_f_ref_arfcn));
   const unsigned nof_crbs =
       band_helper::get_n_rbs_from_bw(base_cell.channel_bw_mhz, base_cell.common_scs, band_helper::get_freq_range(band));
   if (base_cell.pdcch_cfg.common.coreset0_index.has_value()) {
@@ -603,8 +602,7 @@ static bool validate_tdd_ul_dl_unit_config(const du_high_unit_tdd_ul_dl_config&
 
 static bool validate_dl_ul_arfcn_and_band(const du_high_unit_base_cell_config& config)
 {
-  nr_band band =
-      config.band.has_value() ? config.band.value() : band_helper::get_band_from_dl_arfcn(config.dl_f_ref_arfcn);
+  const nr_band band = config.band.value_or(band_helper::get_band_from_dl_arfcn(config.dl_f_ref_arfcn));
 
   // Check if the band is supported with given SCS or band.
   // NOTE: Band n46 would be compatible with the 10MHz BW, but there is no sync raster that falls within the band
@@ -643,7 +641,7 @@ static bool validate_dl_ul_arfcn_and_band(const du_high_unit_base_cell_config& c
     return false;
   }
 
-  // Check whether the DL-ARFCN (and optionally the UL-ARFCN) is within the band and follows the Raster step.
+  // Check whether the DL-ARFCN and the UL-ARFCN are within the band and follow the Raster step.
   if (config.band.has_value()) {
     error_type<std::string> ret = band_helper::is_dl_arfcn_valid_given_band(
         *config.band, config.dl_f_ref_arfcn, config.common_scs, config.channel_bw_mhz);
@@ -655,6 +653,7 @@ static bool validate_dl_ul_arfcn_and_band(const du_high_unit_base_cell_config& c
     const uint32_t ul_arfcn = band_helper::get_ul_arfcn_from_dl_arfcn(config.dl_f_ref_arfcn, config.band.value());
     ret                     = band_helper::is_ul_arfcn_valid_given_band(*config.band, ul_arfcn, config.channel_bw_mhz);
     if (not ret.has_value()) {
+      // NOTE: The message must say that it's the DL ARFCN that is invalid, as that is the parameters set by the user.
       fmt::print("Invalid DL ARFCN={} for band {}. Cause: {}.\n", config.dl_f_ref_arfcn, band, ret.error());
       return false;
     }
@@ -768,9 +767,8 @@ static bool validate_base_cell_unit_config(const du_high_unit_base_cell_config&
     return false;
   }
 
-  const nr_band band =
-      config.band.has_value() ? config.band.value() : band_helper::get_band_from_dl_arfcn(config.dl_f_ref_arfcn);
-  const auto ssb_scs = band_helper::get_most_suitable_ssb_scs(band, config.common_scs);
+  const nr_band band    = config.band.value_or(band_helper::get_band_from_dl_arfcn(config.dl_f_ref_arfcn));
+  const auto    ssb_scs = band_helper::get_most_suitable_ssb_scs(band, config.common_scs);
   if (ssb_scs != config.common_scs) {
     fmt::print("Common SCS {}kHz is not equal to SSB SCS {}kHz. Different SCS for common and SSB is not supported.\n",
                scs_to_khz(config.common_scs),
@@ -840,8 +838,9 @@ static bool validate_cells_unit_config(span<const du_high_unit_cell_config> conf
       fmt::print("Invalid Sector ID {}, for a gNB Id of {} bits\n", cell.cell.sector_id.value(), gnb_id.bit_length);
       return false;
     }
-    const auto   band          = cell.cell.band.value_or(band_helper::get_band_from_dl_arfcn(cell.cell.dl_f_ref_arfcn));
-    bool         is_unlicensed = band_helper::is_unlicensed_band(band);
+    const auto band          = cell.cell.band.value_or(band_helper::get_band_from_dl_arfcn(cell.cell.dl_f_ref_arfcn));
+    bool       is_unlicensed = band_helper::is_unlicensed_band(band);
+    // Check if the RA Response Window (in ms) is within the limits for licensed and unlicensed bands.
     unsigned int max_ra_resp_window = is_unlicensed ? 40 : 10;
     unsigned int ra_resp_window_ms =
         cell.cell.prach_cfg.ra_resp_window.value() >> to_numerology_value(cell.cell.common_scs);

apps/units/flexible_du/split_dynamic/dynamic_du_unit_cli11_schema.cpp

@@ -155,9 +155,9 @@ void srsran::autoderive_dynamic_du_parameters_after_parsing(CLI::App& app, dynam
   }
 
   // Auto derive DU low parameters.
-  const auto& cell = parsed_cfg.du_high_cfg.config.cells_cfg.front().cell;
-  nr_band     band = cell.band ? cell.band.value() : band_helper::get_band_from_dl_arfcn(cell.dl_f_ref_arfcn);
-  bool        is_zmq_rf_driver = false;
+  const auto&   cell = parsed_cfg.du_high_cfg.config.cells_cfg.front().cell;
+  const nr_band band = cell.band ? cell.band.value() : band_helper::get_band_from_dl_arfcn(cell.dl_f_ref_arfcn);
+  bool          is_zmq_rf_driver = false;
   if (std::holds_alternative<ru_sdr_unit_config>(parsed_cfg.ru_cfg)) {
     is_zmq_rf_driver = std::get<ru_sdr_unit_config>(parsed_cfg.ru_cfg).device_driver == "zmq";
   }

include/srsran/ran/ssb_mapping.h

@@ -158,9 +158,6 @@ inline unsigned ssb_get_k_first(frequency_range       fr,
   return (k_first_15kHz * 15) / ssb_scs_kHz;
 }
 
-/// Calculates SSB pattern from SSB subcarrier spacing and DL ARFCN.
-ssb_pattern_case ssb_get_ssb_pattern(subcarrier_spacing ssb_scs, unsigned dl_arfcn);
-
 /// \brief Calculates L_max, ie max number of SSB occasions per SSB period. Possible values are {4, 8, 64}.
 /// \remark See TS 38.213, Section 4.1.
 /// \param ssb_scs SSB Subcarrier Spacing.

lib/du/du_low/du_low_wrapper_factory.cpp

@@ -52,11 +52,11 @@ static fapi::prach_config generate_prach_config_tlv(const du_cell_config& cell_c
 static fapi::carrier_config generate_carrier_config_tlv(const du_cell_config& du_cell)
 {
   // Deduce common numerology and grid size for DL and UL.
-  unsigned numerology       = to_numerology_value(du_cell.scs_common);
-  unsigned grid_size_bw_prb = band_helper::get_n_rbs_from_bw(
-      MHz_to_bs_channel_bandwidth(du_cell.dl_carrier.carrier_bw_mhz),
-      du_cell.scs_common,
-      band_helper::get_freq_range(band_helper::get_band_from_dl_arfcn(du_cell.dl_carrier.arfcn_f_ref)));
+  unsigned numerology = to_numerology_value(du_cell.scs_common);
+  unsigned grid_size_bw_prb =
+      band_helper::get_n_rbs_from_bw(MHz_to_bs_channel_bandwidth(du_cell.dl_carrier.carrier_bw_mhz),
+                                     du_cell.scs_common,
+                                     band_helper::get_freq_range(du_cell.dl_carrier.band));
 
   fapi::carrier_config fapi_config = {};
 

lib/mac/mac_dl/mac_cell_processor.cpp

@@ -36,8 +36,7 @@ mac_cell_processor::mac_cell_processor(const mac_cell_creation_request& cell_cfg
   ue_mng(rnti_table),
   dl_harq_buffers(band_helper::get_n_rbs_from_bw(MHz_to_bs_channel_bandwidth(cell_cfg.dl_carrier.carrier_bw_mhz),
                                                  cell_cfg.scs_common,
-                                                 band_helper::get_freq_range(band_helper::get_band_from_dl_arfcn(
-                                                     cell_cfg.dl_carrier.arfcn_f_ref))),
+                                                 band_helper::get_freq_range(cell_cfg.dl_carrier.band)),
                   cell_cfg.dl_carrier.nof_ant,
                   ctrl_exec_),
   // The PDU pool has to be large enough to fit the maximum number of RARs and Paging PDUs per slot for all possible K0

lib/ran/band_helper.cpp

@@ -56,7 +56,7 @@ struct nr_band_raster {
 // NOTE: FR2 bands have two different Freq raster, we only consider raster 120kHz.
 const uint32_t                                               nof_nr_DL_bands = 83;
 static constexpr std::array<nr_band_raster, nof_nr_DL_bands> nr_band_table   = {{
-    // clang-format off
+      // clang-format off
     {nr_band::n1,    delta_freq_raster::kHz100, 384000, 20,  396000,  422000, 20,  434000},
     {nr_band::n2,    delta_freq_raster::kHz100, 370000, 20,  382000,  386000, 20,  398000},
     {nr_band::n3,    delta_freq_raster::kHz100, 342000, 20,  357000,  361000, 20,  376000},
@@ -159,7 +159,7 @@ struct nr_operating_band {
 };
 static const uint32_t                                                 nof_nr_operating_band = 68;
 static constexpr std::array<nr_operating_band, nof_nr_operating_band> nr_operating_bands    = {{
-    // clang-format off
+       // clang-format off
     {nr_band::n1,  duplex_mode::FDD},
     {nr_band::n2,  duplex_mode::FDD},
     {nr_band::n3,  duplex_mode::FDD},
@@ -836,7 +836,7 @@ srsran::band_helper::is_ul_arfcn_valid_given_band(nr_band band, uint32_t arfcn_f
 uint32_t srsran::band_helper::get_ul_arfcn_from_dl_arfcn(uint32_t dl_arfcn, std::optional<nr_band> band)
 {
   // NOTE: The procedure implemented in this function is implementation-defined.
-  const nr_band operating_band = band.has_value() ? band.value() : get_band_from_dl_arfcn(dl_arfcn);
+  const nr_band operating_band = band.value_or(get_band_from_dl_arfcn(dl_arfcn));
 
   // Return same ARFCN for TDD bands.
   if (get_duplex_mode(operating_band) == duplex_mode::TDD) {

lib/ran/ssb_mapping.cpp

@@ -15,26 +15,17 @@
 
 using namespace srsran;
 
-ssb_pattern_case srsran::ssb_get_ssb_pattern(subcarrier_spacing ssb_scs, unsigned dl_arfcn)
-{
-  nr_band dl_idx_nr_band = band_helper::get_band_from_dl_arfcn(dl_arfcn);
-  srsran_assert(dl_idx_nr_band != nr_band::invalid, "Invalid NR band index");
-  return band_helper::get_ssb_pattern(dl_idx_nr_band, ssb_scs);
-}
-
 uint8_t srsran::ssb_get_L_max(subcarrier_spacing ssb_scs, unsigned dl_arfcn, std::optional<nr_band> band)
 {
   uint8_t L_max = 0;
 
   // Derive the SSB-specific parameters (SSB pattern case, SSB L_max and SSB paired_spectrum flag) from those in the
   // MAC Cell config.
-  if (not band.has_value()) {
-    band.emplace(band_helper::get_band_from_dl_arfcn(dl_arfcn));
-    srsran_assert(band.value() != nr_band::invalid, "Invalid NR band index");
-  }
-  ssb_pattern_case ssb_case = band_helper::get_ssb_pattern(band.value(), ssb_scs);
+  const nr_band gnb_band = band.value_or(band_helper::get_band_from_dl_arfcn(dl_arfcn));
+  srsran_assert(gnb_band != nr_band::invalid, "Invalid NR band index");
+  ssb_pattern_case ssb_case = band_helper::get_ssb_pattern(gnb_band, ssb_scs);
   // Flag indicating whether cell is on paired spectrum (FDD) or unpaired (TDD, SDL, SUL).
-  bool paired_spectrum = band_helper::is_paired_spectrum(band.value());
+  bool paired_spectrum = band_helper::is_paired_spectrum(gnb_band);
 
   // Get L_max from SSB pattern case and carrier frequency and paired spectrum flag.
   uint32_t f_arfcn = dl_arfcn;