du, band_helper: add option to set UL ARFCN

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

Author: carlo-gal

apps/units/flexible_du/du_high/du_high_config.h

@@ -547,6 +547,10 @@ struct du_high_unit_base_cell_config {
   std::optional<unsigned> sector_id;
   /// DL ARFCN of "F_REF", which is the RF reference frequency, as per TS 38.104, Section 5.4.2.1.
   unsigned dl_f_ref_arfcn = 536020;
+  /// UL ARFCN of "F_REF", which is the RF reference frequency, as per TS 38.104, Section 5.4.2.1.
+  /// \remark Only relevant for FDD bands. If set with TDD bands, it will be ignored.
+  /// For FDD bands, if not set, the UL ARFCN will be computed automatically.
+  std::optional<unsigned> ul_f_ref_arfcn = std::nullopt;
   /// Common subcarrier spacing for the entire resource grid. It must be supported by the band SS raster.
   subcarrier_spacing common_scs = subcarrier_spacing::kHz15;
   /// NR band.

apps/units/flexible_du/du_high/du_high_config_cli11_schema.cpp

@@ -1114,6 +1114,7 @@ static void configure_cli11_common_cell_args(CLI::App& app, du_high_unit_base_ce
       ->capture_default_str()
       ->check(CLI::Range(0U, (1U << 14) - 1U));
   add_option(app, "--dl_arfcn", cell_params.dl_f_ref_arfcn, "Downlink ARFCN")->capture_default_str();
+  add_option(app, "--ul_arfcn", cell_params.ul_f_ref_arfcn, "Uplink ARFCN")->capture_default_str();
   add_auto_enum_option(app, "--band", cell_params.band, "NR band");
   add_option_function<std::string>(
       app,

apps/units/flexible_du/du_high/du_high_config_translators.cpp

@@ -230,6 +230,7 @@ std::vector<srs_du::du_cell_config> srsran::generate_du_cell_config(const du_hig
     param.scs_common                               = base_cell.common_scs;
     param.channel_bw_mhz                           = base_cell.channel_bw_mhz;
     param.dl_f_ref_arfcn                           = base_cell.dl_f_ref_arfcn;
+    param.ul_f_ref_arfcn                           = base_cell.ul_f_ref_arfcn;
     param.band                                     = *base_cell.band;
     // Enable CSI-RS if the PDSCH mcs is dynamic (min_ue_mcs != max_ue_mcs).
     param.csi_rs_enabled      = base_cell.csi_cfg.csi_rs_enabled;

apps/units/flexible_du/du_high/du_high_config_validator.cpp

@@ -601,7 +601,7 @@ static bool validate_tdd_ul_dl_unit_config(const du_high_unit_tdd_ul_dl_config&
   return true;
 }
 
-static bool validate_dl_arfcn_and_band(const du_high_unit_base_cell_config& 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);
@@ -643,14 +643,22 @@ static bool validate_dl_arfcn_and_band(const du_high_unit_base_cell_config& conf
     return false;
   }
 
-  // Check whether the DL-ARFCN is within the band and follows the Raster step.
+  // Check whether the DL-ARFCN (and optionally the UL-ARFCN) is within the band and follows 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);
     if (not ret.has_value()) {
       fmt::print("Invalid DL ARFCN={} for band {}. Cause: {}.\n", config.dl_f_ref_arfcn, band, ret.error());
       return false;
     }
+    if (config.ul_f_ref_arfcn.has_value()) {
+      ret =
+          band_helper::is_ul_arfcn_valid_given_band(*config.band, config.ul_f_ref_arfcn.value(), config.channel_bw_mhz);
+      if (not ret.has_value()) {
+        fmt::print("Invalid UL ARFCN={} for band {}. Cause: {}.\n", config.dl_f_ref_arfcn, band, ret.error());
+        return false;
+      }
+    }
   } else {
     if (band == nr_band::invalid) {
       fmt::print("Invalid DL ARFCN={}. Cause: Could not find a valid band.\n", config.dl_f_ref_arfcn);
@@ -757,7 +765,7 @@ static bool validate_base_cell_unit_config(const du_high_unit_base_cell_config&
     fmt::print("Maximum Channel BW with SCS common 120kHz is 400MHz.\n");
     return false;
   }
-  if (!validate_dl_arfcn_and_band(config)) {
+  if (!validate_dl_ul_arfcn_and_band(config)) {
     return false;
   }
 

include/srsran/ran/band_helper.h

@@ -85,6 +85,14 @@ error_type<std::string> is_dl_arfcn_valid_given_band(nr_band              band,
                                                      subcarrier_spacing   scs,
                                                      bs_channel_bandwidth bw = bs_channel_bandwidth::MHz10);
 
+/// \brief     Checks whether an Uplink ARFCN is valid for a given band.
+/// \param[in] band Given NR band.
+/// \param[in] arfcn_f_ref Given Uplink ARFCN of \c F_REF, as per TS 38.104, Section 5.4.2.1.
+/// \param[in] bw Channel Bandwidth in MHz, which is required to validate some bands' ARFCN values.
+/// \return    If the UL ARFCN is invalid for the band, a std::string value is returned with the reason.
+error_type<std::string>
+is_ul_arfcn_valid_given_band(nr_band band, uint32_t arfcn_f_ref, bs_channel_bandwidth bw = bs_channel_bandwidth::MHz10);
+
 /// @brief Get the respective UL ARFCN of a DL ARFCN.
 ///
 /// For paired spectrum (FDD) the function returns the respective ARFCN in the same band.

include/srsran/scheduler/config/cell_config_builder_params.h

@@ -31,6 +31,11 @@ struct cell_config_builder_params {
   /// This ARFCN represents "f_ref" for DL, as per TS 38.104, Section 5.4.2.1. As per TS 38.104, Section 5.4.2.2,
   /// "f_ref" maps to the central frequency of the band.
   unsigned dl_f_ref_arfcn = 365000;
+  /// This ARFCN represents "f_ref" for UL, as per TS 38.104, Section 5.4.2.1. As per TS 38.104, Section 5.4.2.2,
+  /// "f_ref" maps to the central frequency of the band.
+  /// \remark Only relevant for FDD bands.
+  /// If set, this value has been set by the application user.
+  std::optional<unsigned> ul_f_ref_arfcn = std::nullopt;
   /// <em>NR operating band<\em>, as per Table 5.2-1 and 5.2-2, TS 38.104. If not specified, a valid band for the
   /// provided DL ARFCN is automatically derived.
   std::optional<nr_band> band;

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},
@@ -150,7 +150,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},
@@ -456,30 +456,33 @@ static bool is_valid_raster_param(const nr_raster_params& raster)
 
 // Validates band n28, which has an additional ARFCN value to the given interval, as per Table 5.4.2.3-1, TS 38.104,
 // version 17.8.0.
-static error_type<std::string> validate_band_n28(uint32_t arfcn, bs_channel_bandwidth bw)
+static error_type<std::string> validate_band_n28(uint32_t arfcn, bs_channel_bandwidth bw, bool is_dl = true)
 {
   const nr_band_raster band_raster = fetch_band_raster(nr_band::n28, {});
   if (band_raster.band == srsran::nr_band::invalid) {
     return make_unexpected(fmt::format("Band n28 channel raster not found"));
   }
 
   // Try first if the ARFCN matches any value of the interval for 100kHz channel raster.
-  if (arfcn >= band_raster.dl_nref_first and arfcn <= band_raster.dl_nref_last and
-      ((arfcn - band_raster.dl_nref_first) % band_raster.dl_nref_step) == 0) {
+  uint32_t nref_first = is_dl ? band_raster.dl_nref_first : band_raster.ul_nref_first;
+  uint32_t nref_last  = is_dl ? band_raster.dl_nref_last : band_raster.ul_nref_last;
+  uint32_t nref_step  = is_dl ? band_raster.dl_nref_step : band_raster.ul_nref_step;
+  if (arfcn >= nref_first and arfcn <= nref_last and ((arfcn - nref_first) % nref_step) == 0) {
     return error_type<std::string>{};
   }
 
   // Extra ARFCN value as per Table 5.4.2.3-1, TS 38.104, version 17.8.0 (see NOTE 4 in the table).
-  const uint32_t dl_arfnc_40MHz = 155608U;
-  if (bw == srsran::bs_channel_bandwidth::MHz40 and arfcn == dl_arfnc_40MHz) {
+  const uint32_t arfnc_40MHz = is_dl ? 155608U : 144608U;
+  if (bw == srsran::bs_channel_bandwidth::MHz40 and arfcn == arfnc_40MHz) {
     return error_type<std::string>{};
   }
 
   return make_unexpected(
-      fmt::format("DL ARFCN must be within the interval [{},{}], in steps of {}, for the chosen band",
-                  band_raster.dl_nref_first,
-                  band_raster.dl_nref_last,
-                  band_raster.dl_nref_step));
+      fmt::format("{} ARFCN must be within the interval [{},{}], in steps of {}, for the chosen band",
+                  is_dl ? "DL" : "UL",
+                  nref_first,
+                  nref_last,
+                  nref_step));
 }
 
 // Validates band n46, whose valid ARFCN values depend on the channel BW, as per Table 5.4.2.3-1, TS 38.104,
@@ -743,7 +746,7 @@ error_type<std::string> srsran::band_helper::is_dl_arfcn_valid_given_band(nr_ban
 {
   // Validates first the bands with non-standard ARFCN values.
   if (band == nr_band::n28) {
-    return validate_band_n28(arfcn_f_ref, bw);
+    return validate_band_n28(arfcn_f_ref, bw, true);
   }
 
   if (band == nr_band::n46) {
@@ -796,6 +799,37 @@ error_type<std::string> srsran::band_helper::is_dl_arfcn_valid_given_band(nr_ban
   return make_unexpected(fmt::format("Band {} is not valid", band));
 }
 
+error_type<std::string>
+srsran::band_helper::is_ul_arfcn_valid_given_band(nr_band band, uint32_t arfcn_f_ref, bs_channel_bandwidth bw)
+{
+  if (get_duplex_mode(band) != duplex_mode::FDD) {
+    return {};
+  }
+
+  // Validates first the bands with non-standard ARFCN values.
+  if (band == nr_band::n28) {
+    return validate_band_n28(arfcn_f_ref, bw, false);
+  }
+
+  // Assume standard Delta freq raster of 100kHz.
+  const delta_freq_raster band_delta_freq_raster = delta_freq_raster::kHz100;
+
+  for (const nr_band_raster& raster_band : nr_band_table) {
+    if (raster_band.band == band and raster_band.delta_f_rast == band_delta_freq_raster) {
+      if (arfcn_f_ref >= raster_band.ul_nref_first and arfcn_f_ref <= raster_band.ul_nref_last and
+          ((arfcn_f_ref - raster_band.ul_nref_first) % raster_band.ul_nref_step) == 0) {
+        return {};
+      }
+      return make_unexpected(
+          fmt::format("UL ARFCN must be within the interval [{},{}], in steps of {}, for the chosen band",
+                      raster_band.ul_nref_first,
+                      raster_band.ul_nref_last,
+                      raster_band.ul_nref_step));
+    }
+  }
+  return make_unexpected(fmt::format("Band {} is not valid", band));
+}
+
 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.

lib/scheduler/config/serving_cell_config_factory.cpp

@@ -89,7 +89,9 @@ static carrier_configuration make_default_carrier_configuration(const cell_confi
     cfg.arfcn_f_ref = params.dl_f_ref_arfcn;
     cfg.nof_ant     = params.nof_dl_ports;
   } else {
-    cfg.arfcn_f_ref = band_helper::get_ul_arfcn_from_dl_arfcn(params.dl_f_ref_arfcn, cfg.band);
+    cfg.arfcn_f_ref = params.ul_f_ref_arfcn.has_value()
+                          ? params.ul_f_ref_arfcn.value()
+                          : band_helper::get_ul_arfcn_from_dl_arfcn(params.dl_f_ref_arfcn, cfg.band);
     cfg.nof_ant     = 1;
   }
   const min_channel_bandwidth min_channel_bw = band_helper::get_min_channel_bw(cfg.band, params.scs_common);
@@ -334,7 +336,9 @@ srsran::config_helpers::make_default_ul_config_common(const cell_config_builder_
 {
   ul_config_common cfg{};
   // This is the ARFCN of the UL f_ref, as per TS 38.104, Section 5.4.2.1.
-  const uint32_t ul_arfcn                 = band_helper::get_ul_arfcn_from_dl_arfcn(params.dl_f_ref_arfcn, params.band);
+  const uint32_t ul_arfcn                 = params.ul_f_ref_arfcn.has_value()
+                                                ? params.ul_f_ref_arfcn.value()
+                                                : band_helper::get_ul_arfcn_from_dl_arfcn(params.dl_f_ref_arfcn, params.band);
   const double   ul_absolute_freq_point_a = band_helper::get_abs_freq_point_a_from_f_ref(
       band_helper::nr_arfcn_to_freq(ul_arfcn), params.cell_nof_crbs, params.scs_common);
   // \c absolute_freq_point_a needs to be expressed as in ARFCN, as per \c absoluteFrequencyPointA definition in 38.211,