redac.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
//
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#include "redac/calibration.h"
#include "utils/timer.h"
 
 
#include <redac/redac.h>
#include <utils/logging.h>
 
blocks::TBlockBackplane *platform::REDAC::init_backpanel_tblock(uint8_t baddr, const char *name) {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
  LOGV("Detecting Backpanel %s Block...", name);
  blocks::TBlockBackplane *t_block = entities::detect<blocks::TBlockBackplane>(bus::address_from_tuple(baddr, 0));
  if (!t_block) {
    LOG(ANABRID_DEBUG_INIT, "Warning: The backplane T block is missing or unknown...");
    return nullptr;
  }
 
  LOG(ANABRID_DEBUG_INIT, "Initializing the backplane T Block...");
  t_block->rename_entity(name); // otherwise it appears wrong in the entity tree
  auto t_block_result = t_block->init();
  if (!t_block_result) {
    LOG(ANABRID_DEBUG_INIT, "Backplane T-Block Failed");
    LOG(ANABRID_DEBUG_INIT, t_block_result.err_value().c_str());
    return nullptr;
  }
 
  LOG(ANABRID_DEBUG_INIT, "Backplane T-Block initialized.");
  return t_block;
}
 
bool platform::REDAC::init() {
  LOG(ANABRID_DEBUG_INIT, __PRETTY_FUNCTION__);
  if(!Carrier::init())
    return false;
  routing.init(entity_id);
 
  // Read BP identifier from hardware
  bp_identifier = BackPanelIdentifier(hardware->read_backplane_and_slot_id());
 
  // Detect T-block
  if (!carrier_t_block) {
    LOG(ANABRID_DEBUG_INIT, "Detecting Carrier T-Block...");
    carrier_t_block = entities::detect<blocks::TBlock>(bus::address_from_tuple(bus::CARRIER_T_BLOCK_BADDR, 0));
    if (!carrier_t_block) {
      LOG(ANABRID_DEBUG_INIT, "Warning: Carrier T-Block is missing or unknown.");
    } else {
      LOG(ANABRID_DEBUG_INIT, "Initializing Carrier T-Block...");
      if(!carrier_t_block->init())
        return false;
      LOG(ANABRID_DEBUG_INIT, "Carrier T-Block initialized.");
    }
  }
  if (!back_panel) {
    LOG(ANABRID_DEBUG_INIT, "Detecting back panel...");
    back_panel = entities::detect<platform::REDACBackPanel>(bus::address_from_tuple(bus::BACKPLANE_BADDR, 0));
    if (!back_panel)
      LOG(ANABRID_DEBUG_INIT, "Warning: Back panel is missing or unknown.");
  }
 
  if (!stack_t0_block)
    stack_t0_block = init_backpanel_tblock(bus::BPL_T0_BLOCK_BADDR, platform::REDAC::STACK_T0_NAME);
  if (!stack_t1_block)
    stack_t1_block = init_backpanel_tblock(bus::BPL_T1_BLOCK_BADDR, platform::REDAC::STACK_T1_NAME);
  if (!stack_t2_block)
    stack_t2_block = init_backpanel_tblock(bus::BPL_T2_BLOCK_BADDR, platform::REDAC::STACK_T2_NAME);
 
  return UnitResult::ok();
}
 
platform::REDAC::REDAC(REDAC_HAL *hardware) : Carrier({Cluster(0), Cluster(1), Cluster(2)}, hardware), hardware(hardware) {}
 
platform::BackPanelIdentifier platform::REDAC::get_back_panel_identifier() const { return bp_identifier; }
 
void platform::REDAC::reset(entities::ResetAction action) {
  Carrier::reset(action);
 
  for (auto *t_block : get_all_tblocks())
    if (t_block)
      t_block->reset(action);
 
  hardware->reset_adc_bus_mux();
}
 
void platform::REDAC::power_up() { hardware->set_standby(false); }
 
void platform::REDAC::power_down() { hardware->set_standby(true); }
 
bool platform::REDAC::write_to_hardware() {
  if(!Carrier::write_to_hardware())
    return false;
 
  for (auto t_block : get_all_tblocks()) {
    if (!t_block) continue;
    if(!t_block->write_to_hardware())
      return false;
  }
 
  return true;
}
 
UnitResult platform::REDAC::route_cross_cluster(uint8_t start_cluster, uint8_t end_cluster, uint8_t u_in, uint8_t u_out, float c_factor, uint8_t i_out) {
  if (start_cluster > 2 || end_cluster > 2)
    return UnitResult::err("Invalid cluster indices. Valid ranges are 0 to 2");
 
  if (u_out < 8)
    return UnitResult::err("Can not connect a lane lower then 8 across multiple clusters");
 
  auto *ublock = clusters[start_cluster].ublock;
  auto *cblock = clusters[start_cluster].cblock;
  auto *iblock = clusters[end_cluster].iblock;
 
  // Connect different clusters together
  carrier_t_block->connect(static_cast<blocks::TBlock::Sector>(start_cluster + 1), static_cast<blocks::TBlock::Sector>(end_cluster + 1), u_out - 8);
 
  if (fabs(c_factor) > 1.0f) {
    c_factor = c_factor / 8.0f;
    iblock->set_upscaling(u_out, true);
  } else
    iblock->set_upscaling(u_out, false);
 
  TRY(ublock->connect(u_in, u_out));
  TRY(cblock->set_factor(u_out, c_factor));
  TRY(iblock->connect(u_out, i_out));
  return UnitResult::ok();
}
 
UnitResult platform::REDAC::route_to_backplane(uint8_t start_cluster, uint8_t u_in, uint8_t u_out, float c_factor) {
  if (start_cluster > 2)
    return UnitResult::err("Invalid cluster index. Valid ranges are 0 to 2");
 
  if (u_out < 8)
    return UnitResult::err("Can not connect a lane lower then 8 to backplane");
 
  auto *ublock = clusters[start_cluster].ublock;
  auto *cblock = clusters[start_cluster].cblock;
 
  carrier_t_block->connect(static_cast<blocks::TBlock::Sector>(start_cluster + 1), blocks::TBlock::Sector::BPL, u_out - 8);
 
  if (!ublock->connect(u_in, u_out))
    return UnitResult::err("U block connection not possible");
  if (!cblock->set_factor(u_out, c_factor))
    return UnitResult::err("C block configuration not possible, remember there is no automatic upscaling");
  return UnitResult::ok();
}
 
UnitResult platform::REDAC::route_from_backplane(uint8_t end_cluster, uint8_t i_in, uint8_t i_out) {
  if (end_cluster > 2)
    return UnitResult::err("Invalid cluster index. Valid ranges are 0 to 2");
 
  if (i_in < 8)
    return UnitResult::err("Can not connect a lane lower then 8 to backplane");
 
  auto *iblock = clusters[end_cluster].iblock;
 
  carrier_t_block->connect(blocks::TBlock::Sector::BPL, static_cast<blocks::TBlock::Sector>(end_cluster + 1), i_in - 8);
 
  TRY(iblock->connect(i_in, i_out));
  return UnitResult::ok();
}
 
UnitResult platform::REDAC::route_on_backplane(blocks::TBlockBackplane::Sector start_sector, blocks::TBlockBackplane::Sector end_sector,
                                           uint8_t lane_idx) {
  if (!back_panel)
    return UnitResult::err("No backplane was accessible!");
  if (back_panel->get_entity_version() < entities::Version(2, 0, 0))
    return UnitResult::err("The detected backplane is using old topology, which is no longer supported");
 
  blocks::TBlockBackplane *required_t_block = nullptr;
  if (lane_idx < 8 || lane_idx > 31)
    return UnitResult::err("Invalid lane index for backplane signal");
  else if (lane_idx < 16)
    required_t_block = stack_t0_block;
  else if (lane_idx < 24)
    required_t_block = stack_t1_block;
  else if (lane_idx < 32)
    required_t_block = stack_t2_block;
 
  if (!required_t_block)
    return UnitResult::err("The required backplane t-block could not be found!");
 
  return required_t_block->connect(start_sector, end_sector, lane_idx % 8);
}
 
UnitResult platform::REDAC::calibrate_offsets() {
  LOG_ANABRID_DEBUG_CALIBRATION("Halting external signal sources");
 
  std::vector<std::array<uint32_t, blocks::IBlock::NUM_OUTPUTS>> old_iblock_connections;
  for (auto &cluster : clusters) {
    old_iblock_connections.emplace_back(cluster.iblock->get_outputs());
    // Search for signals that are coming from external sources
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE()) {
      for (auto i_in_idx : blocks::IBlock::INPUT_IDX_RANGE()) {
        if (i_in_idx <= 7) // No T-Block connections on those lanes
          continue;
 
        // Only do something is this lane is connected
        if (!cluster.iblock->is_connected(i_in_idx, i_out_idx))
          continue;
 
        // Now check where the T-Block connects us to
        auto dest_sector = static_cast<blocks::TBlock::Sector>(cluster.get_cluster_idx() + 1);
        auto src = carrier_t_block->src_of_signal(dest_sector, i_in_idx - 8);
 
        // Carrier internal routing => no problem to take care of
        if (src != blocks::TBlock::Sector::BPL)
          continue;
 
        // Disconnect in I Block
        cluster.iblock->disconnect(i_in_idx, i_out_idx);
      }
    }
    TRY_TRUE(cluster.iblock->write_to_hardware());
  }
 
  LOG_ANABRID_DEBUG_CALIBRATION("Calibrating all offsets");
 
  std::vector<std::pair<blocks::UBlock::Transmission_Mode, blocks::UBlock::Transmission_Mode>> old_transmission_modes;
  std::vector<blocks::UBlock::Reference_Magnitude> old_reference_magnitudes;
  for (auto &cluster : clusters) {
    old_transmission_modes.push_back(cluster.ublock->get_all_transmission_modes());
    old_reference_magnitudes.push_back(cluster.ublock->get_reference_magnitude());
    cluster.ublock->change_all_transmission_modes(blocks::UBlock::Transmission_Mode::GROUND);
 
    TRY_TRUE(cluster.ublock->write_to_hardware());
  }
 
  delay(10);
 
  for (auto &cluster : clusters)
    cluster.shblock->compensate_hardware_offsets();
 
  for (size_t i = 0; i < clusters.size(); i++) {
    clusters[i].ublock->change_all_transmission_modes(old_transmission_modes[i]);
    clusters[i].ublock->change_reference_magnitude(old_reference_magnitudes[i]);
 
    TRY_TRUE(clusters[i].ublock->write_to_hardware());
  }
 
  LOG_ANABRID_DEBUG_CALIBRATION("Resuming external signal sources");
 
  for (size_t i = 0; i < clusters.size(); i++) {
    clusters[i].iblock->set_outputs(old_iblock_connections[i]);
    TRY_TRUE(clusters[i].iblock->write_to_hardware());
  }
 
  delay(10);
  return UnitResult::ok();
}
 
UnitResult platform::REDAC::calibrate_routes() {
  // Save and change ADC bus selection
  auto old_adcbus = ctrl_block->get_adc_bus();
  auto old_adc_channels = get_adc_channels();
 
  reset_adc_channels();
 
  ctrl_block->set_adc_bus(blocks::CTRLBlock::ADCBus::ADC);
  TRY_TRUE(ctrl_block->write_to_hardware());
 
  // Save and change cluster block settings
  LOG_ANABRID_DEBUG_CALIBRATION("Enable u-block reference");
 
  std::vector<std::pair<blocks::UBlock::Transmission_Mode, blocks::UBlock::Transmission_Mode>> old_transmission_modes;
  std::vector<blocks::UBlock::Reference_Magnitude> old_reference_magnitudes;
  for (auto &cluster : clusters) {
    old_transmission_modes.push_back(cluster.ublock->get_all_transmission_modes());
    old_reference_magnitudes.push_back(cluster.ublock->get_reference_magnitude());
    cluster.ublock->change_all_transmission_modes(blocks::UBlock::Transmission_Mode::POS_REF);
 
    TRY_TRUE(cluster.ublock->write_to_hardware());
  }
 
  LOG_ANABRID_DEBUG_CALIBRATION("Reset c-blocks");
  std::vector<std::array<float, blocks::CBlock::NUM_COEFF>> old_c_block_factors;
  for (auto &cluster : clusters) {
    old_c_block_factors.push_back(cluster.cblock->get_factors());
    cluster.cblock->set_factors({});
 
    TRY_TRUE(cluster.cblock->write_to_hardware());
  }
 
  for (auto &cluster : clusters) {
    LOG_ANABRID_DEBUG_CALIBRATION(("Calibrating routes ending in cluster " + std::to_string(cluster.get_cluster_idx())).c_str());
 
    // We dont need to worry about clusters that dont have connections
    if (!cluster.iblock->is_anything_connected())
      continue;
 
    // Find an M block usable for its identity lanes
    blocks::MBlock *id_block = nullptr;
    if (cluster.m0block && cluster.m0block->has_id_lanes())
      id_block = cluster.m0block;
 
    if (!id_block && cluster.m1block && cluster.m1block->has_id_lanes())
      id_block = cluster.m1block;
 
    if (!id_block) {
      return UnitResult::err("No M Block with ID Lanes found, calibration impossible!");
    }
 
    uint8_t id_in_lane = 0, id_out_lane = 4;
    for (auto i = 0; i < id_block->ID_OUTPUT_CONNECTIONS().size(); i++) {
      if (id_block->ID_OUTPUT_CONNECTIONS()[i] != -1) {
        id_out_lane = id_block->slot_to_global_io_index(i);
        id_in_lane = id_block->slot_to_global_io_index(id_block->ID_OUTPUT_CONNECTIONS()[i]);
        break;
      }
    }
 
    std::array<std::vector<uint8_t>, blocks::IBlock::NUM_OUTPUTS> old_i_block_connections;
    std::array<std::vector<uint8_t>, blocks::IBlock::NUM_OUTPUTS> old_i_block_connections_uncalibrated;
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE()) {
      for (auto i_in_idx : blocks::IBlock::INPUT_IDX_RANGE()) {
        // Only do something is this lane is used in the original I-block configuration
        if (!cluster.iblock->is_connected(i_in_idx, i_out_idx))
          continue;
 
        uint8_t src_cluster = cluster.get_cluster_idx();
 
        // Now check where the t-block connects us to but only if the signal actually goes through the t block
        if (i_in_idx > 7) {
          auto src = carrier_t_block->src_of_signal(static_cast<blocks::TBlock::Sector>(cluster.get_cluster_idx() + 1), i_in_idx - 8);
 
          if (src == blocks::TBlock::Sector::BPL) {
            LOG_ANABRID_DEBUG_CALIBRATION("Signal starts on backplane, we can't work with this");
            old_i_block_connections_uncalibrated[i_out_idx].emplace_back(i_in_idx);
            continue;
          }
 
          src_cluster = src - 1;
 
          if (src_cluster >= clusters.size())
            continue; // This can only happen in debug with less than three clusters
        }
 
        // If we don't have a complete connection through the u block, we don't need / we can't calibrate this
        // route from here
        if (!clusters[src_cluster].ublock->is_output_connected(i_in_idx))
          continue;
 
        // Store this i block input to output connection
        old_i_block_connections[i_out_idx].emplace_back(i_in_idx);
      }
    }
    cluster.iblock->reset_outputs();
    TRY_TRUE(cluster.iblock->write_to_hardware());
 
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE()) {
      for (auto i_in_idx : old_i_block_connections[i_out_idx])
        TRY (cluster.iblock->connect(i_in_idx, id_in_lane));
 
      TRY_TRUE(cluster.iblock->write_to_hardware());
 
      // Now switch through all relevant input signals and put one of them to 1.0
      for (auto i_in_idx : old_i_block_connections[i_out_idx]) {
        LOG_ANABRID_DEBUG_CALIBRATION(i_in_idx);
        LOG_ANABRID_DEBUG_CALIBRATION(i_out_idx);
 
        auto *ublock = cluster.ublock;   // U Block might be in different cluster
        auto *cblock = cluster.cblock;   // C Block might be in different cluster
        auto *iblock = cluster.iblock;   // I Block is always in the cluster we are operating in
        auto *shblock = cluster.shblock; // SH Block is always in the cluster we are operating in
 
        // First check where the t-block connects us to but only if the signal actually goes through the t
        // block
        if (i_in_idx > 7) {
          auto src = carrier_t_block->src_of_signal(static_cast<blocks::TBlock::Sector>(cluster.get_cluster_idx() + 1), i_in_idx - 8);
 
          if (src == blocks::TBlock::Sector::BPL) {
            LOG_ANABRID_DEBUG_CALIBRATION("Signal starts on backplane, we can't work with this");
            continue;
          }
 
          uint8_t src_cluster = src - 1;
 
          LOG_ANABRID_DEBUG_CALIBRATION(("Signal starts in cluster " + std::to_string(src_cluster)).c_str());
 
          if (src_cluster >= clusters.size())
            continue; // This can only happen in debug with less then three clusters
 
          // Now we now from which cluster the signals start
          ublock = clusters[src_cluster].ublock;
          cblock = clusters[src_cluster].cblock;
        }
 
        // Setup measure path
        TRY(set_adc_channel(0, id_out_lane, cluster.get_cluster_idx()));
        if (!hardware->write_adc_bus_mux(m_adc_channels))
          return UnitResult::err("Writing adcs failed!");
 
        // Depending on whether upscaling is enabled for this lane, we apply +1 or +0.1 reference
        // This is done on all lanes (but no other I-block connection exists, so no other current flows)
        bool upscaled_channel = iblock->get_upscaling(i_in_idx);
        ublock->change_reference_magnitude(upscaled_channel ? blocks::UBlock::Reference_Magnitude::ONE_TENTH
                                                            : blocks::UBlock::Reference_Magnitude::ONE);
        TRY_TRUE(cluster.ublock->write_to_hardware());
 
        // First measure the offset of each measuring lane. The SH Block can not calibrate offsets that occur
        // after himself so we need to take care of that.
        TRY(cblock->set_factor(i_in_idx, 0.0f));
        TRY(cblock->set_gain_correction(i_in_idx, 1.0f));
        TRY_TRUE(cblock->write_to_hardware());
 
        // Calibrate offsets for this specific route
        TRY(calibrate_offsets());
 
        auto measured_offset = -daq::average(daq::sample, 4, 10)[0];
        LOG_ANABRID_DEBUG_CALIBRATION(measured_offset);
 
        // Allow this connection to go up to full scale. Those values are allways legal so we can ignore the
        // return value
        TRY(cblock->set_factor(i_in_idx, 1.0f));
        TRY_TRUE(cblock->write_to_hardware());
 
        delay(10);
 
        // Measure gain output
        auto measured_gain = -daq::average(daq::sample, 4, 10)[0];
        LOG_ANABRID_DEBUG_CALIBRATION(measured_gain);
        // Calculate necessary gain correction
        auto gain_correction = (upscaled_channel ? 0.8f : 1.0f) / (measured_gain - measured_offset);
        LOG_ANABRID_DEBUG_CALIBRATION(gain_correction);
        if (gain_correction > 1.1f) {
          LOG_ALWAYS("Gain correction is too high, this is probably a problem with the hardware");
          gain_correction = 1.1f;
        }
        // Set gain correction on C-block, which will automatically get applied when writing to hardware
        TRY(cblock->set_gain_correction(i_in_idx, gain_correction));
        // Deactivate this lane again
        TRY(cblock->set_factor(i_in_idx, 0.0f));
        TRY_TRUE(cblock->write_to_hardware());
        LOG_ANABRID_DEBUG_CALIBRATION(" ");
      }
 
      cluster.iblock->reset_outputs();
      reset_adc_channels();
    }
 
    // Restore I-block connections
    LOG_ANABRID_DEBUG_CALIBRATION("Restoring i-block");
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE())
      for (auto i_in_idx : old_i_block_connections[i_out_idx])
        TRY(cluster.iblock->connect(i_in_idx, i_out_idx));
    for (auto i_out_idx : blocks::IBlock::OUTPUT_IDX_RANGE())
      for (auto i_in_idx : old_i_block_connections_uncalibrated[i_out_idx])
        TRY (cluster.iblock->connect(i_in_idx, i_out_idx));
 
    TRY_TRUE(cluster.iblock->write_to_hardware());
  }
 
  LOG_ANABRID_DEBUG_CALIBRATION("Restoring u-blocks");
  for (size_t i = 0; i < clusters.size(); i++) {
    clusters[i].ublock->change_all_transmission_modes(old_transmission_modes[i]);
    clusters[i].ublock->change_reference_magnitude(old_reference_magnitudes[i]);
 
    TRY_TRUE(clusters[i].ublock->write_to_hardware());
  }
 
  LOG_ANABRID_DEBUG_CALIBRATION("Restoring c-blocks");
  for (size_t i = 0; i < clusters.size(); i++) {
    clusters[i].cblock->set_factors(old_c_block_factors[i]);
    TRY_TRUE(clusters[i].cblock->write_to_hardware());
  }
 
  // Restore ADC bus selection
  ctrl_block->set_adc_bus(old_adcbus);
  TRY_TRUE(ctrl_block->write_to_hardware());
 
  TRY(set_adc_channels(old_adc_channels));
  if (!hardware->write_adc_bus_mux(m_adc_channels))
    return UnitResult::err("Writing adcs failed");
 
  // Calibrate offsets for complete path
  TRY(calibrate_offsets());
 
  return UnitResult::ok();
}
 
std::vector<entities::Entity *> platform::REDAC::get_child_entities() {
  auto entities = this->carrier::Carrier::get_child_entities();
  if (back_panel)
    entities.push_back(back_panel);
  for (auto *t_block : get_all_tblocks())
    if (t_block)
      entities.push_back(t_block);
  return entities;
}
 
entities::Entity *platform::REDAC::get_child_entity(std::string_view child_id) {
  if (child_id == "BP")
    return back_panel;
  if (child_id == "T")
    return carrier_t_block;
  if (child_id == platform::REDAC::STACK_T0_NAME)
    return stack_t0_block;
  if (child_id == platform::REDAC::STACK_T1_NAME)
    return stack_t1_block;
  if (child_id == platform::REDAC::STACK_T2_NAME)
    return stack_t2_block;
  return this->Carrier::get_child_entity(child_id);
}
 
void platform::REDAC::extract(entities::ExtractVisitor &collector) {
  Carrier::extract(collector);
 
  if (!collector.include_configuration()) return;
  auto &config = collector.create(pb_Item_backpanel_config_tag);
  auto &backpanel_config = config.kind.backpanel_config;
 
  auto identifier = get_back_panel_identifier();
 
  backpanel_config.backpanel_id = identifier.backpanel_id;
  backpanel_config.backpanel_slot = identifier.backpanel_slot;
  backpanel_config.is_valid = identifier.valid;
  backpanel_config.is_isolated = identifier.isolated;
}
 
UnitResult platform::REDAC::calibrate(const pb_CalibrationConfig &item)
{
  Sync timer;
  if (item.gain != pb_CalibrationConfig_Kind_Disabled) {
    std::string_view path_view(item.leader.path);
    bool is_leader = item.has_leader && path_view == get_entity_id();
 
    std::unique_ptr<CalibrationBase> base;
    if (is_leader) {
      base = std::make_unique<CalibrationLeader>(*this);
    } else {
      base = std::make_unique<CalibrationFollower>(*this);
    }
 
    uint32_t ms_calibration_sync = item.math * 15000 + item.offset * 150 + 200;
    timer.sync_at_ms(ms_calibration_sync);
    auto do_result = base->do_();
    if (!do_result) {
      LOG_ERROR("ERROR during calibration");
      LOG_ERROR(do_result.err_value().c_str());
      return do_result;
    }
 
    LOG_ALWAYS("Calibration done.")
  }else if (item.offset != pb_CalibrationConfig_Kind_Disabled) {
    //only locally
    TRY(calibrate_offsets());
  }
 
  if(item.math != pb_CalibrationConfig_Kind_Disabled) {
    //following calibrations are not configuration preserving
    entities::Setup setup;
    entities::ExtractSettings settings{
      .include_configuration = true
    };
    setup.extract(this, settings);
    reset(entities::ResetAction::CIRCUIT_RESET);
    TRY_TRUE(write_to_hardware());
    TRY(calibrate_m_blocks());
 
    TRY(setup.apply(this, true));
  }
 
  return UnitResult::ok();
}
 
ConfigResult platform::REDAC::config(const pb_Item &item) {
  if (item.which_kind == pb_Item_dependency_info_tag || item.which_kind == pb_Item_ip_lookup_table_tag) {
    return routing.config(item);
  }
 
  if (item.which_kind == pb_Item_backpanel_config_tag) {
    return ConfigResult::ok(true);
  }
 
  return Carrier::config(item);
}