tblock.cpp

Go to the documentation of this file.

#include <entity/visitor.h>
#include <proto/main.pb.h>
 
#include <redac/tblock.h>
 
using namespace blocks;
 
TBlock::TBlock(TBlockHAL *hardware) : FunctionBlock("T", hardware), hardware(hardware) { classifier.class_enum = CLASS_; }
 
ConfigResult TBlock::config(const pb_Config &cfg) {
  if (cfg.which_kind == pb_Config_switch_config_tag) {
    auto &switch_config = cfg.kind.switch_config;
    return apply_muxes(switch_config.muxes);
  }
 
  if (cfg.which_kind == pb_UseConfig_uses_tag) {
    auto &use_config = cfg.kind.use_config;
    return apply_uses(use_config.uses);
  }
 
  // unhandled
  return ConfigResult::ok(false);
}
 
ConfigResult TBlock::apply_muxes(const pb_Mux (&muxes)[TBlockHAL::NUM_SWITCHES]) {
  size_t idx = -1;
  for (auto &mux : muxes) {
    idx++;
    if (!mux.has_state)
      // Mux is not required for this configuration, keep it in previous configuration.
      // The rest of the configuration must ensure that this is not a problem.
      continue;
 
    auto mux_value = mux.state;
    if (mux_value < 0 || 4 <= mux_value)
      return ConfigResult::err("TBlock: Mux must be interval [0, 3]");
    connections[idx] = mux_value;
  }
 
  return ConfigResult::ok(true);
}
 
ConfigResult TBlock::apply_uses(const pb_Use (&uses)[TBlockHAL::NUM_SWITCHES]) {
  for (auto &use : uses) {
    external_signal_sources[use.idx] = use.has_source ? static_cast<int32_t>(use.source) : -1;
    external_target_upscaling[use.idx] = use.upscaled;
  }
 
  return ConfigResult::ok(true);
}
 
std::array<uint8_t, TBlockHAL::NUM_SWITCHES> TBlock::get_connections() const { return connections; }
 
void TBlock::set_connections(const std::array<uint8_t, TBlockHAL::NUM_SWITCHES> &connections) { this->connections = connections; }
 
void TBlock::extract(entities::ExtractVisitor &collector) {
  auto &cfg = collector.create(pb_Config_switch_config_tag);
  auto &switch_config = cfg.kind.switch_config = pb_SwitchConfig_init_default;
 
  auto &idx = switch_config.muxes_count = 0;
  for (; idx < connections.size(); ++idx) {
    switch_config.muxes[idx] = {
        .has_state = true,
        .state = connections[idx],
    };
  }
}
 
status TBlock::connect(Sector src_sector, Sector dst_sector, uint8_t lane_idx) {
  if (lane_idx > 23)
    return status("Invalid lane. Remember that TBlock lanes are allways counted from 0 to 23");
 
  connections[lane_idx * 4 + dst_sector] = src_sector;
 
  return status::success();
}
 
TBlock::Sector TBlock::src_of_signal(Sector dst_sector, uint8_t lane_idx) const {
  if (lane_idx > 23)
    return Sector::BPL;
 
  return static_cast<Sector>(connections[lane_idx * 4 + dst_sector]);
}
 
void reset_external_signal_infos();
 
void TBlock::reset(entities::ResetAction action) {
  Entity::reset(action);
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_connections();
    reset_external_signal_infos();
  }
  if (action.has(entities::ResetAction::EVERYTHING))
    enabled = true;
}
 
void TBlock::reset_external_signal_infos() {
  external_signal_sources = {};
  external_target_upscaling = {};
}
 
void TBlock::reset_connections() {
  // Note that the T-block always has connections, unless it is completely disabled (powered-off).
  // The least surprising default connection is to have signals stay in their originating cluster.
  connections = {Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2,
                 Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0,
                 Sector::CL1, Sector::CL2, Sector::BPL, Sector::CL0, Sector::CL1, Sector::CL2};
}
 
status TBlock::write_to_hardware() {
  RETURN_IF_FAILED(Entity::write_to_hardware());
  if (!hardware->write_muxes(connections))
    return status("Error writing mux settings to hardware.");
  if (enabled)
    hardware->reset_mux_disable();
  else
    hardware->set_mux_disable();
  return status::success();
}
 
bool TBlock::is_enabled() const { return enabled; }
 
void TBlock::set_enabled(bool enabled_) { enabled = enabled_; }
 
int32_t TBlock::get_external_signal_source_entity_id(Sector dst_sector, uint8_t lane_idx) {
  // Lane is elem [0, 23]
  if (lane_idx > 23)
    return -1;
  return external_signal_sources[lane_idx * 4 + dst_sector];
}
 
bool TBlock::is_external_target_upscaled(uint8_t lane) {
  if (lane >= 24)
    return false;
  return external_target_upscaling[lane];
}
 
TBlockBackplane::TBlockBackplane(TBlockBackplaneHAL *hardware) : FunctionBlock("T_BPL", hardware), hardware(hardware) {
  classifier.class_enum = CLASS_;
}
 
utils::status TBlockBackplane::connect(Sector src_sector, Sector dst_sector, uint8_t lane_idx) {
  if (lane_idx > 7)
    return "lane_idx is invalid! Maximum is 7!";
 
  if (src_sector == dst_sector)
    return "src_sector is equal to dst_sector! This connection is impossible!";
 
 
  uint8_t switch_setting = src_sector;
  if (src_sector == Sector::EXT0)
    switch_setting = dst_sector;
 
  connections[dst_sector + lane_idx * 9] = switch_setting;
 
  return status::success();
}
 
TBlockBackplane::Sector TBlockBackplane::src_of_signal(Sector dst_sector, uint8_t lane_idx) const {
  if (lane_idx > 7)
    return Sector::EXT0;
 
  uint8_t switch_setting = connections[dst_sector + lane_idx * 9];
  if (switch_setting == dst_sector)
    return EXT0;
 
  return static_cast<Sector>(switch_setting);
}
 
void TBlockBackplane::reset(entities::ResetAction action) {
  Entity::reset(action);
  if (action.has(entities::ResetAction::CIRCUIT_RESET)) {
    reset_connections();
  }
  if (action.has(entities::ResetAction::EVERYTHING))
    enabled = true;
}
 
void TBlockBackplane::reset_connections() {
  // Resetting probably doesnt make much sense, because there really is no default way of connecting the redacs on the backplane
  // Because of that and because all connections are always active after a reset the tblock gets a random configuration, to make spotting routing
  // errors easier
  std::fill(connections.begin(), connections.end(), random() % 9);
}
 
status TBlockBackplane::write_to_hardware() {
  RETURN_IF_FAILED(Entity::write_to_hardware());
  if (!hardware->write_muxes(connections))
    return status("Error writing mux settings to hardware.");
  if (enabled)
    hardware->reset_mux_disable();
  else
    hardware->set_mux_disable();
  return status::success();
}
 
std::array<uint8_t, TBlockBackplaneHAL::NUM_SWITCHES> TBlockBackplane::get_connections() const { return connections; }
 
void TBlockBackplane::set_connections(const std::array<uint8_t, TBlockBackplaneHAL::NUM_SWITCHES> &connections_) { connections = connections_; }
 
bool TBlockBackplane::is_enabled() const { return enabled; }
 
void TBlockBackplane::set_enabled(bool enabled_) { enabled = enabled_; }
 
ConfigResult TBlockBackplane::config(const pb_Config &cfg) {
  if (cfg.which_kind == pb_Config_bpl_switch_config_tag) {
    auto &switch_config = cfg.kind.bpl_switch_config;
    return apply_muxes(switch_config.muxes);
  }
 
  return ConfigResult::ok(false);
}
 
ConfigResult TBlockBackplane::apply_muxes(const pb_Mux (&muxes)[TBlockBackplaneHAL::NUM_SWITCHES]) {
  for (size_t i = 0; i < TBlockBackplaneHAL::NUM_SWITCHES; i++) {
    if (!muxes[i].has_state)
      continue;
 
    auto mux_value = muxes[i].state;
    if (mux_value > 7)
      return ConfigResult::err("TBlockBackplane::apply_muxes: mux value is invalid, must be between [0, 7]!");
    connections[i] = mux_value;
  }
 
  return ConfigResult::ok(true);
}
 
void TBlockBackplane::extract(entities::ExtractVisitor &collector) {
  auto &cfg = collector.create(pb_Config_bpl_switch_config_tag);
  auto &switch_config = cfg.kind.bpl_switch_config = pb_BPLSwitchConfig_init_default;
 
  auto &idx = switch_config.muxes_count = 0;
  for (; idx < connections.size(); ++idx) {
    switch_config.muxes[idx] = {.has_state = true, .state = connections[idx]};
  }
}