IONode.cpp

Go to the documentation of this file.

 
#include "timing/IONode.hpp"
 
#include "logging/Logging.hpp"
 
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace dunedaq {
namespace timing {
 
// UHAL_REGISTER_DERIVED_NODE(IONode);
 
//-----------------------------------------------------------------------------
IONode::IONode(const uhal::Node& node,
               std::string uid_i2c_bus,
               std::string pll_i2c_bus,
               std::string pll_i2c_device,
               std::vector<std::string> clock_names,
               std::vector<std::string> sfp_i2c_buses)
  : TimingNode(node)
  , m_uid_i2c_bus(uid_i2c_bus)
  , m_pll_i2c_bus(pll_i2c_bus)
  , m_pll_i2c_device(pll_i2c_device)
  , m_clock_names(clock_names)
  , m_sfp_i2c_buses(sfp_i2c_buses)
// mPLL (new SI534xSlave( getNode<I2CMasterNode>(m_pll_i2c_bus)& ,
// getNode<I2CMasterNode>(m_pll_i2c_bus).get_slave_address(pll_i2c_device) ))
{}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
IONode::~IONode() {}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t // NOLINT(build/unsigned)
IONode::read_board_type() const
{
  uhal::ValWord<uint32_t> board_type = getNode("config.board_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return board_type.value();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t // NOLINT(build/unsigned)
IONode::read_carrier_type() const
{
  uhal::ValWord<uint32_t> carrier_type = getNode("config.carrier_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return carrier_type.value();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t // NOLINT(build/unsigned)
IONode::read_design_type() const
{
  uhal::ValWord<uint32_t> design_type = getNode("config.design_type").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return design_type.value();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint32_t // NOLINT(build/unsigned)
IONode::read_firmware_frequency() const
{
  uhal::ValWord<uint32_t> firmware_frequency = getNode("config.clock_frequency").read(); // NOLINT(build/unsigned)
  getClient().dispatch();
  return firmware_frequency.value();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
uint64_t // NOLINT(build/unsigned)
IONode::read_board_uid() const
{
 
  uint64_t uid = 0;                // NOLINT(build/unsigned)
  std::vector<uint8_t> uid_values = // NOLINT(build/unsigned)
    getNode<I2CMasterNode>(m_uid_i2c_bus).get_slave(get_uid_address_parameter_name()).read_i2cArray(0xfa, 6);
 
  for (uint8_t i = 0; i < uid_values.size(); ++i) { // NOLINT(build/unsigned)
    uid = (uid << 8) | uid_values.at(i);
  }
  return uid;
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
BoardRevision
IONode::get_board_revision() const
{
  auto uid = read_board_uid();
  try {
    return get_board_uid_revision_map().at(uid);
  } catch (const std::out_of_range& e) {
    ers::warning(UnknownBoardUID(ERS_HERE, format_reg_value(uid), e));
    return kBoardRevisionUnknown;
  }
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
IONode::get_hardware_info(bool print_out) const
{
  std::stringstream info;
  const BoardType board_type = convert_value_to_board_type(read_board_type());
  const BoardRevision board_revision = get_board_revision();
  const CarrierType carrier_type = convert_value_to_carrier_type(read_carrier_type());
  const DesignType design_type = convert_value_to_design_type(read_design_type());
  const double firmware_frequency = read_firmware_frequency()/1e6;
 
  std::vector<std::pair<std::string, std::string>> hardware_info;
 
  try {
    hardware_info.push_back(std::make_pair("Board type", get_board_type_map().at(board_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingBoardTypeMapEntry(ERS_HERE, format_reg_value(board_type), e));
  }
 
  try {
    hardware_info.push_back(std::make_pair("Board revision", get_board_revision_map().at(board_revision)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingBoardRevisionMapEntry(ERS_HERE, format_reg_value(board_revision), e));
  }
 
  hardware_info.push_back(std::make_pair("Board UID", format_reg_value(read_board_uid())));
 
  try {
    hardware_info.push_back(std::make_pair("Carrier type", get_carrier_type_map().at(carrier_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingCarrierTypeMapEntry(ERS_HERE, format_reg_value(carrier_type), e));
  }
 
  try {
    hardware_info.push_back(std::make_pair("Design type", get_design_type_map().at(design_type)));
  } catch (const std::out_of_range& e) {
    ers::error(MissingDesignTypeMapEntry(ERS_HERE, format_reg_value(design_type), e));
  }
 
  hardware_info.push_back(std::make_pair("Firmware frequency [MHz]", std::to_string(firmware_frequency)));
 
  info << format_reg_table(hardware_info, "Hardware info", { "", "" });
 
  if (print_out)
    TLOG() << info.str();
  return info.str();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
IONode::get_full_clock_config_file_path(const ClockSource& clock_source) const
{
  std::string config_file;
  std::stringstream clock_config_key;
 
  const BoardType board_type = convert_value_to_board_type(read_board_type());
//    const BoardRevision board_revision = get_board_revision();
  const CarrierType carrier_type = convert_value_to_carrier_type(read_carrier_type());
  const DesignType design_type = convert_value_to_design_type(read_design_type());
  //const uint32_t firmware_frequency = read_firmware_frequency(); // NOLINT(build/unsigned)
 
  try {
    clock_config_key << get_board_type_map().at(board_type) << "_";
  } catch (const std::out_of_range& e) {
    throw MissingBoardTypeMapEntry(ERS_HERE, format_reg_value(board_type), e);
  }
 
  auto pll = get_pll();
  auto pll_model = pll->read_device_version();
  clock_config_key << std::hex << pll_model;
 
//    try {
//      clock_config_key = clock_config_key + get_carrier_type_map().at(carrier_type) + "_";
//    } catch (const std::out_of_range& e) {
//      throw MissingCarrierTypeMapEntry(ERS_HERE, format_reg_value(carrier_type), e);
//    }
 
  try {
    clock_config_key << "_" << get_design_type_map().at(design_type);
  } catch (const std::out_of_range& e) {
    throw MissingDesignTypeMapEntry(ERS_HERE, format_reg_value(design_type), e);
  }
 
  clock_config_key << "_" << clock_source_to_string(clock_source);
 
  TLOG_DEBUG(0) << "Using pll config key: " << clock_config_key.str();
 
  try {
    config_file = get_clock_config_map().at(clock_config_key.str());
  } catch (const std::out_of_range& e) {
    throw ClockConfigNotFound(ERS_HERE, clock_config_key.str(), e);
  }
 
  TLOG_DEBUG(0) << "PLL config file: " << config_file << " from key: " << clock_config_key.str();
 
  const char* env_var_char = std::getenv("TIMING_SHARE");
 
  if (env_var_char == nullptr) {
    throw EnvironmentVariableNotSet(ERS_HERE, "TIMING_SHARE");
  }
 
  std::string env_var(env_var_char);
 
  std::string full_pll_config_file_path = env_var + "/config/etc/clock/" + config_file;
 
  TLOG_DEBUG(0) << "Full PLL config file path: " << full_pll_config_file_path;
 
  return full_pll_config_file_path;
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::unique_ptr<const SI534xSlave>
IONode::get_pll() const
{
  return get_i2c_device<SI534xSlave>(m_pll_i2c_bus, m_pll_i2c_device);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
IONode::configure_pll(const std::string& clock_config_file) const
{
  auto pll = get_pll();
 
  TLOG() << "PLL configuration file : " << clock_config_file;
 
  uint32_t si_pll_version = pll->read_device_version(); // NOLINT(build/unsigned)
  TLOG_DEBUG(0) << "Configuring PLL        : SI" << format_reg_value(si_pll_version);
 
  pll->configure(clock_config_file);
 
  TLOG_DEBUG(0) << "PLL configuration id   : " << pll->read_config_id();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::vector<double>
IONode::read_clock_frequencies() const
{
  return getNode<FrequencyCounterNode>("freq").measure_frequencies(m_clock_names.size());
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
IONode::get_clock_frequencies_table(bool print_out) const
{
  std::stringstream table;
  std::vector<double> frequencies = read_clock_frequencies();
  for (uint8_t i = 0; i < frequencies.size(); ++i) { // NOLINT(build/unsigned)
    table << m_clock_names.at(i) << " freq: " << std::setprecision(12) << frequencies.at(i) << std::endl;
  }
  // TODO add freq validation Stoyan Trilov stoyan.trilov@cern.ch
  if (print_out)
    TLOG() << table.str();
  return table.str();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
IONode::get_pll_status(bool print_out) const
{
  return get_pll()->get_status(print_out);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
IONode::write_soft_reset_register() const
{
  getNode("csr.ctrl.soft_rst").write(0x1);
  getClient().dispatch();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
IONode::soft_reset() const
{
  write_soft_reset_register();
  TLOG_DEBUG(0) << "Soft reset done";
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
IONode::reset(const ClockSource& clock_source) const
{
  TLOG() << "Setting IO preliminaries: I2C access, etc..";
  set_up_io_infrastructure();
 
  // Find the right pll config file
  std::string clock_config = get_full_clock_config_file_path(clock_source);
  reset(clock_config);
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
std::string
IONode::get_sfp_status(uint32_t sfp_id, bool print_out) const // NOLINT(build/unsigned)
{
  std::stringstream status;
  std::string sfp_i2c_bus;
  try {
    sfp_i2c_bus = m_sfp_i2c_buses.at(sfp_id);
  } catch (const std::out_of_range& e) {
    throw InvalidSFPId(ERS_HERE, format_reg_value(sfp_id), e);
  }
  auto sfp = get_i2c_device<I2CSFPSlave>(sfp_i2c_bus, "SFP_EEProm");
  status << sfp->get_status();
  if (print_out)
    TLOG() << status.str();
  return status.str();
}
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
void
IONode::switch_sfp_soft_tx_control_bit(uint32_t sfp_id, bool turn_on) const // NOLINT(build/unsigned)
{
  std::string sfp_i2c_bus;
  try {
    sfp_i2c_bus = m_sfp_i2c_buses.at(sfp_id);
  } catch (const std::out_of_range& e) {
    throw InvalidSFPId(ERS_HERE, format_reg_value(sfp_id), e);
  }
  auto sfp = get_i2c_device<I2CSFPSlave>(sfp_i2c_bus, "SFP_EEProm");
  sfp->switch_soft_tx_control_bit(turn_on);
}
//-----------------------------------------------------------------------------
 
} // namespace timing
} // namespace dunedaq