dunedaq::flxlibs::CardControllerWrapper Class Reference

#include <CardControllerWrapper.hpp>

Inheritance diagram for dunedaq::flxlibs::CardControllerWrapper:

Collaboration diagram for dunedaq::flxlibs::CardControllerWrapper:

Public Types
using	data_t = nlohmann::json
Public Types inherited from dunedaq::opmonlib::MonitorableObject
using	NodePtr = std::weak_ptr<MonitorableObject>
using	NewNodePtr = std::shared_ptr<MonitorableObject>
using	ElementId = std::string

Public Member Functions
	CardControllerWrapper (uint32_t device_id, const appmodel::FelixInterface *flx_cfg, const std::vector< const appmodel::FelixDataSender * > &flx_senders)
	CardControllerWrapper Constructor.
	~CardControllerWrapper ()
	CardControllerWrapper (const CardControllerWrapper &)=delete
	Not copy-constructible.
CardControllerWrapper &	operator= (const CardControllerWrapper &)=delete
	Not copy-assignable.
	CardControllerWrapper (CardControllerWrapper &&)=delete
	Not move-constructible.
CardControllerWrapper &	operator= (CardControllerWrapper &&)=delete
	Not move-assignable.
void	init ()
void	configure (uint16_t super_chunk_size, bool emu_fanout)
uint64_t	get_register (std::string key)
void	set_register (std::string key, uint64_t value)
uint64_t	get_bitfield (std::string key)
void	set_bitfield (std::string key, uint64_t value)
void	gth_reset ()
void	check_alignment (uint64_t aligned)
Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject (const MonitorableObject &)=delete
MonitorableObject &	operator= (const MonitorableObject &)=delete
	MonitorableObject (MonitorableObject &&)=delete
MonitorableObject &	operator= (MonitorableObject &&)=delete
virtual	~MonitorableObject ()=default
auto	get_opmon_id () const noexcept
auto	get_opmon_level () const noexcept

Protected Member Functions
void	generate_opmon_data () override
Protected Member Functions inherited from dunedaq::opmonlib::MonitorableObject
	MonitorableObject ()=default
void	register_node (ElementId name, NewNodePtr)
void	publish (google::protobuf::Message &&, CustomOrigin &&co={}, OpMonLevel l=to_level(EntryOpMonLevel::kDefault)) const noexcept

Private Types
using	UniqueFlxCard = std::unique_ptr<FlxCard>

Private Member Functions
void	open_card ()
void	close_card ()

Private Attributes
uint32_t	m_device_id
const appmodel::FelixInterface *	m_flx_cfg
const std::vector< const appmodel::FelixDataSender * >	m_flx_senders
UniqueFlxCard	m_flx_card
std::mutex	m_card_mutex

Additional Inherited Members
Static Public Member Functions inherited from dunedaq::opmonlib::MonitorableObject
static bool	publishable_metric (OpMonLevel entry, OpMonLevel system) noexcept

Detailed Description

Definition at line 27 of file CardControllerWrapper.hpp.

Member Typedef Documentation

data_t

using dunedaq::flxlibs::CardControllerWrapper::data_t = nlohmann::json

Definition at line 40 of file CardControllerWrapper.hpp.

UniqueFlxCard

using dunedaq::flxlibs::CardControllerWrapper::UniqueFlxCard = std::unique_ptr<FlxCard>

private

Definition at line 64 of file CardControllerWrapper.hpp.

Constructor & Destructor Documentation

CardControllerWrapper() [1/3]

dunedaq::flxlibs::CardControllerWrapper::CardControllerWrapper	(	uint32_t	device_id,
		const appmodel::FelixInterface *	flx_cfg,
		const std::vector< const appmodel::FelixDataSender * > &	flx_senders )

CardControllerWrapper Constructor.

Definition at line 40 of file CardControllerWrapper.cpp.

                                                                                                                                                                     : 
m_device_id(device_id),
m_flx_cfg(flx_cfg),
m_flx_senders(flx_senders)
{
 
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS)
    << "CardControllerWrapper constructor called. Open card " << m_device_id;
    
  m_flx_card = std::make_unique<FlxCard>();
  if (m_flx_card == nullptr) {
    ers::fatal(flxlibs::CardError(ERS_HERE, "Couldn't create FlxCard object."));
  }
  open_card();
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "CardControllerWrapper constructed.";
 
}

~CardControllerWrapper()

dunedaq::flxlibs::CardControllerWrapper::~CardControllerWrapper

(

)

Definition at line 58 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS)
    << "CardControllerWrapper destructor called. First stop check, then closing card.";
  close_card();
  TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << "CardControllerWrapper destroyed.";
}

CardControllerWrapper() [2/3]

dunedaq::flxlibs::CardControllerWrapper::CardControllerWrapper ( const CardControllerWrapper & )

delete

Not copy-constructible.

CardControllerWrapper() [3/3]

dunedaq::flxlibs::CardControllerWrapper::CardControllerWrapper ( CardControllerWrapper && )

delete

Not move-constructible.

Member Function Documentation

check_alignment()

void dunedaq::flxlibs::CardControllerWrapper::check_alignment

(

uint64_t

aligned

)

Definition at line 200 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Checking link alignment for " << m_flx_cfg->get_slr();
 
  bool emu_fanout = get_bitfield("FE_EMU_ENA_EMU_TOHOST");
  // check the alingment on a logical unit
  for(auto s : m_flx_senders) {
    // here we want to print out a log message when the links do not appear to be aligned.
    // for WIB readout link_id 5 is always reserved for tp links, so alignemnt is not expected fort these
#warning FIXME: Horrible remapping workaround. Temporary fix only! 
    auto id_to_check = m_flx_cfg->get_slr() * 6 + s->get_link();
    bool is_aligned = aligned & (1<<id_to_check);
    // auto found_link = std::find(std::begin(alignment_mask), std::end(alignment_mask), li.link_id);
    // if(found_link == std::end(alignment_mask)) {
    //   if(!lu_cfg.emu_fanout && !is_aligned) {
    //     ers::error(flxlibs::ChannelAlignment(ERS_HERE, li.link_id));
    //   }
    // }
    if(!emu_fanout && !is_aligned) {
      ers::error(flxlibs::ChannelAlignment(ERS_HERE, s->get_link()));
    }
  }
}

close_card()

void dunedaq::flxlibs::CardControllerWrapper::close_card ( )

private

Definition at line 143 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Closing FELIX card " << m_device_id;
  try {
    const std::lock_guard<std::mutex> lock(m_card_mutex);
    m_flx_card->card_close();
  } catch (FlxException& ex) {
    ers::error(flxlibs::CardError(ERS_HERE, ex.what()));
    exit(EXIT_FAILURE);
  }
}

configure()

void dunedaq::flxlibs::CardControllerWrapper::configure	(	uint16_t	super_chunk_size,
		bool	emu_fanout )

Definition at line 89 of file CardControllerWrapper.cpp.

{
  // Disable all links
  for(size_t i=0 ; i<12; ++i) {
    // std::stringstream ss;
    // ss << "DECODING_LINK" << std::setw(2) << std::setfill('0') << i << "_EGROUP0_CTRL_EPATH_ENA";
    set_bitfield(fmt::format("DECODING_LINK{:02}_EGROUP0_CTRL_EPATH_ENA", i), 0);
  }
 
  // Enable/disable emulation
  if(emu_fanout) {
    //set_bitfield("FE_EMU_LOGIC_IDLES", 0); // FIXME
    //set_bitfield("FE_EMU_LOGIC_CHUNK_LENGTH", 0);
    //set_bitfield("FE_EMU_LOGIC_ENA", 0);
    //set_bitfield("FE_EMU_LOGIC_L1A_TRIGGERED", 0);
 
    set_bitfield("GBT_TOFRONTEND_FANOUT_SEL", 0);
    set_bitfield("GBT_TOHOST_FANOUT_SEL", 0xffffff);
    set_bitfield("FE_EMU_ENA_EMU_TOFRONTEND", 0);
    set_bitfield("FE_EMU_ENA_EMU_TOHOST", 1);
  }
  else {
    //set_register("FE_EMU_LOGIC_ENA", 0);
    //set_register("FE_EMU_LOGIC_L1A_TRIGGERED", 0);
    //set_register("FE_EMU_LOGIC_IDLES", 0);
    //set_register("FE_EMU_LOGIC_CHUNK_LENGTH", 0);
 
    set_bitfield("FE_EMU_ENA_EMU_TOFRONTEND", 0);
    set_bitfield("FE_EMU_ENA_EMU_TOHOST", 0);
    set_bitfield("GBT_TOFRONTEND_FANOUT_SEL", 0);
    set_bitfield("GBT_TOHOST_FANOUT_SEL", 0);
  }
  // Enable and configure the right links
 
  for(auto s : m_flx_senders) {
    set_bitfield(fmt::format("SUPER_CHUNK_FACTOR_LINK_{:02}",s->get_link()), super_chunk_size);
    set_bitfield(fmt::format("DECODING_LINK{:02}_EGROUP0_CTRL_EPATH_ENA",s->get_link()), 1);
  }
}

generate_opmon_data()

void dunedaq::flxlibs::CardControllerWrapper::generate_opmon_data ( )

overrideprotectedvirtual

Hook for customisable pubblication. The function can throw, exception will be caught by the monitoring thread

Reimplemented from dunedaq::opmonlib::MonitorableObject.

Definition at line 225 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Monitoring link alignment for " << m_flx_cfg->get_slr();
 
  uint64_t aligned = get_register(REG_GBT_ALIGNMENT_DONE);
  
  for(auto s : m_flx_senders) {
 
    opmon::LinkInfo i;
    i.set_enabled(true);
#warning FIXME: Horrible remapping workaround. Temporary fix only!
    auto id_to_check = m_flx_cfg->get_slr() * 6 + s->get_link();
    bool is_aligned = aligned & (1<<id_to_check);
    i.set_aligned( is_aligned );
    publish( std::move(i),
         { {"device", fmt::format("{}", m_device_id) },
           {"link",   fmt::format("{}", s->get_link()) } });
    
  } // loop over links
}

get_bitfield()

uint64_t dunedaq::flxlibs::CardControllerWrapper::get_bitfield

(

std::string

key

)

Definition at line 173 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Reading value of bitfield " << key;
  const std::lock_guard<std::mutex> lock(m_card_mutex);
  auto bf_val = m_flx_card->cfg_get_option(key.c_str(), false);
  return bf_val;
}

get_register()

uint64_t dunedaq::flxlibs::CardControllerWrapper::get_register

(

std::string

key

)

Definition at line 156 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Reading value of register " << key;
  const std::lock_guard<std::mutex> lock(m_card_mutex);
  auto reg_val = m_flx_card->cfg_get_reg(key.c_str());
  return reg_val;
}

gth_reset()

void dunedaq::flxlibs::CardControllerWrapper::gth_reset

(

)

Definition at line 190 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Resetting GTH";
  const std::lock_guard<std::mutex> lock(m_card_mutex);
  for (auto i=0 ; i< 6; ++i) {
      m_flx_card->gth_rx_reset(i);
  }    
}

init()

void dunedaq::flxlibs::CardControllerWrapper::init

(

)

Definition at line 67 of file CardControllerWrapper.cpp.

                            {
 
 // Card initialization
 // this is complicated....should we repeat all code in flx_init?
 // For now do not do the configs of the clock chips
 const std::lock_guard<std::mutex> lock(m_card_mutex);
 m_flx_card->cfg_set_option( BF_MMCM_MAIN_LCLK_SEL, 1 ); // local clock
 m_flx_card->soft_reset();
 //si5328_configure();
 //si5345_configure(0);
 m_flx_card->cfg_set_option(BF_GBT_SOFT_RESET, 0xFFFFFFFFFFFF);
 m_flx_card->cfg_set_option(BF_GBT_SOFT_RESET, 0);
 
 int bad_channels = m_flx_card->gbt_setup( FLX_GBT_ALIGNMENT_ONE, FLX_GBT_TMODE_FEC ); //What does this do?
 if(bad_channels) {
    TLOG()<< bad_channels << " not aligned.";
 }
 m_flx_card->irq_disable( ALL_IRQS );
 
}

open_card()

void dunedaq::flxlibs::CardControllerWrapper::open_card ( )

private

Definition at line 130 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Opening FELIX card " << m_device_id;
  try {
    const std::lock_guard<std::mutex> lock(m_card_mutex);
    m_flx_card->card_open(static_cast<int>(m_device_id), LOCK_NONE); // FlxCard.h
  } catch (FlxException& ex) {
    ers::error(flxlibs::CardError(ERS_HERE, ex.what()));
    exit(EXIT_FAILURE);
  }
}

operator=() [1/2]

CardControllerWrapper & dunedaq::flxlibs::CardControllerWrapper::operator= ( CardControllerWrapper && )

delete

Not move-assignable.

operator=() [2/2]

CardControllerWrapper & dunedaq::flxlibs::CardControllerWrapper::operator= ( const CardControllerWrapper & )

delete

Not copy-assignable.

set_bitfield()

void dunedaq::flxlibs::CardControllerWrapper::set_bitfield	(	std::string	key,
		uint64_t	value )

Definition at line 182 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Setting value of bitfield " << key << " to " << value;;
  const std::lock_guard<std::mutex> lock(m_card_mutex);
  m_flx_card->cfg_set_option(key.c_str(), value, false);
}

set_register()

void dunedaq::flxlibs::CardControllerWrapper::set_register	(	std::string	key,
		uint64_t	value )

Definition at line 165 of file CardControllerWrapper.cpp.

{
  TLOG_DEBUG(TLVL_WORK_STEPS) << "Setting value of register " << key << " to " << value;
  const std::lock_guard<std::mutex> lock(m_card_mutex);
  m_flx_card->cfg_set_reg(key.c_str(), value);
}

Member Data Documentation

m_card_mutex

std::mutex dunedaq::flxlibs::CardControllerWrapper::m_card_mutex

private

Definition at line 70 of file CardControllerWrapper.hpp.

m_device_id

uint32_t dunedaq::flxlibs::CardControllerWrapper::m_device_id

private

Definition at line 61 of file CardControllerWrapper.hpp.

m_flx_card

UniqueFlxCard dunedaq::flxlibs::CardControllerWrapper::m_flx_card

private

Definition at line 69 of file CardControllerWrapper.hpp.

m_flx_cfg

const appmodel::FelixInterface* dunedaq::flxlibs::CardControllerWrapper::m_flx_cfg

private

Definition at line 66 of file CardControllerWrapper.hpp.

m_flx_senders

const std::vector<const appmodel::FelixDataSender*> dunedaq::flxlibs::CardControllerWrapper::m_flx_senders

private

Definition at line 67 of file CardControllerWrapper.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/flxlibs/src/CardControllerWrapper.hpp
• /github/workspace/dunedaq/sourcecode/flxlibs/src/CardControllerWrapper.cpp