uhallibs::Flx::Card Class Reference

Public Member Functions
	Card (const std::string &aPath, u_int aLockMask)
	~Card ()
const std::string &	getPath () const
int	getDeviceId () const
void	open ()
void	close ()
void	read (const uint32_t aAddr, const uint32_t aNrWords, std::vector< uint32_t > &aValues)
void	write (const uint32_t aAddr, const std::vector< std::pair< const uint8_t *, size_t > > &aData)
bool	haveLock () const
void	lock ()
void	unlock ()

Static Private Member Functions
static regmap_register_t *	find_reg (const std::string &aName)

Private Attributes
std::string	mPath
int	mDeviceId
u_int	mLockMask
FlxCard	mFlxCard
bool	mIsOpen
int	mFd
bool	mLocked

Detailed Description

Definition at line 100 of file ProtocolFlx.hpp.

Constructor & Destructor Documentation

Card()

uhallibs::Flx::Card::Card	(	const std::string &	aPath,
		u_int	aLockMask )

Definition at line 93 of file ProtocolFlx.cpp.

  : mPath(aDevicePath)
  , mLockMask(aLockMask)
  , mFlxCard()
  , mIsOpen(false)
{
 
  const std::string prefix("/dev/flx");
  if (aDevicePath.rfind(prefix, 0) != 0) {
 
    exception::FlxInvalidDevice lExc;
    log(lExc, "Invalid device path ", uhal::Quote(mPath));
    throw lExc;
  }
 
  std::string device_id_str = aDevicePath.substr(prefix.size()).data();
  try {
    mDeviceId = std::stoi(device_id_str);
  } catch (std::invalid_argument const& ex) {
 
    exception::FlxInvalidDevice lExc;
    log(lExc, "Invalid device id ", uhal::Quote(mPath));
    throw lExc;
  }
}

~Card()

uhallibs::Flx::Card::~Card

(

)

Definition at line 120 of file ProtocolFlx.cpp.

{}

Member Function Documentation

close()

void uhallibs::Flx::Card::close

(

)

Definition at line 154 of file ProtocolFlx.cpp.

{
 
  if (mIsOpen)
    mFlxCard.card_close();
 
  if (mFd != -1) {
    if (haveLock())
      unlock();
    int rc = ::close(mFd);
    mFd = -1;
    if (rc == -1)
      log(uhal::Error(),
          "Failed to close file ",
          uhal::Quote(mPath),
          "; errno=",
          uhal::Integer(errno),
          ", meaning ",
          uhal::Quote(strerror(errno)));
  }
}

find_reg()

regmap_register_t * uhallibs::Flx::Card::find_reg ( const std::string & aName )

staticprivate

Definition at line 79 of file ProtocolFlx.cpp.

{
 
  regmap_register_t* reg;
  for (reg = regmap_registers; reg->name != NULL; reg++) {
    if (aName == reg->name) {
      return reg;
    }
  }
 
  return nullptr;
}

getDeviceId()

int uhallibs::Flx::Card::getDeviceId

(

)

const

Definition at line 185 of file ProtocolFlx.cpp.

{
  return mDeviceId;
}

getPath()

const std::string & uhallibs::Flx::Card::getPath

(

)

const

Definition at line 178 of file ProtocolFlx.cpp.

{
  return mPath;
}

haveLock()

bool uhallibs::Flx::Card::haveLock

(

)

const

Definition at line 271 of file ProtocolFlx.cpp.

{
  return mLocked;
}

lock()

void uhallibs::Flx::Card::lock

(

)

Definition at line 277 of file ProtocolFlx.cpp.

{
  if (flock(mFd, LOCK_EX) == -1) {
    ipc::exception::MutexError lExc;
    log(lExc,
        "Failed to lock device file ",
        uhal::Quote(mPath),
        "; errno=",
        uhal::Integer(errno),
        ", meaning ",
        uhal::Quote(strerror(errno)));
    throw lExc;
  }
  mLocked = true;
}

open()

void uhallibs::Flx::Card::open

(

)

Definition at line 124 of file ProtocolFlx.cpp.

{
 
  log(uhal::Debug(), "Flx::Card client Opening felix endpoint ", mDeviceId, " on ", mPath);
 
  if (access(mPath.c_str(), F_OK) == -1) {
 
    exception::FlxInitialisationError lExc;
    log(lExc,
        "Failed to open device file ",
        uhal::Quote(mPath),
        "; errno=",
        uhal::Integer(errno),
        ", meaning ",
        uhal::Quote(strerror(errno)));
    throw lExc;
  }
 
  mFd = ::open(mPath.c_str(), O_RDWR);
  if (mFd < 0) {
    return;
  }
 
  mFlxCard.card_open(mDeviceId, mLockMask);
 
  mIsOpen = true;
}

read()

void uhallibs::Flx::Card::read	(	const uint32_t	aAddr,
		const uint32_t	aNrWords,
		std::vector< uint32_t > &	aValues )

Definition at line 192 of file ProtocolFlx.cpp.

{
 
  if (!mIsOpen)
    open();
 
  flxcard_bar2_regs_t* bar2 = (flxcard_bar2_regs_t*)mFlxCard.openBackDoor(2);
 
  // +1 is ceiling rounding in integers
  uint32_t lNrReads64b = (aNrWords + 1) / 2;
  uint32_t lAddr = aAddr / 2;
 
  for (uint32_t i(0); i < lNrReads64b; i++) {
    // *lReadAddrPtr = lAddr+i;
    bar2->IPBUS_READ_ADDRESS = lAddr + i;
    // uint64_t lDataWord = *lReadDataPtr;
    uint64_t lDataWord = bar2->IPBUS_READ_DATA;
    // Split the 64b word in 32b chunks
    aValues.push_back(lDataWord & 0xffffffff);
    if (2 * i + 1 < aNrWords)
      aValues.push_back(lDataWord >> 32);
  }
 
  log(uhal::Debug(), "Flx::Card::read, ", aNrWords, " requested, ", aValues.size(), " read");
}

unlock()

void uhallibs::Flx::Card::unlock

(

)

Definition at line 294 of file ProtocolFlx.cpp.

{
  if (flock(mFd, LOCK_UN) == -1) {
    log(uhal::Warning(),
        "Failed to unlock device file ",
        uhal::Quote(mPath),
        "; errno=",
        uhal::Integer(errno),
        ", meaning ",
        uhal::Quote(strerror(errno)));
  } else
    mLocked = false;
}

write()

void uhallibs::Flx::Card::write	(	const uint32_t	aAddr,
		const std::vector< std::pair< const uint8_t *, size_t > > &	aData )

Definition at line 220 of file ProtocolFlx.cpp.

{
 
  if (!mIsOpen)
    open();
 
  flxcard_bar2_regs_t* bar2 = (flxcard_bar2_regs_t*)mFlxCard.openBackDoor(2);
 
  size_t lNrBytes = 0;
  for (size_t i = 0; i < aData.size(); i++)
    lNrBytes += aData.at(i).second;
 
  assert((lNrBytes % 4) == 0);
 
  char* allocated = NULL;
  posix_memalign((void**)&allocated, 4096 /*alignment*/, lNrBytes + 4096);
  if (allocated == NULL) {
    exception::FlxCommunicationError lExc;
    log(lExc, "Failed to allocate ", uhal::Integer(lNrBytes + 4096), " bytes in File::write/2 function");
    throw lExc;
  }
 
  // data to write to register address
  char* buffer = allocated;
  size_t lNrBytesCopied = 0;
  for (size_t i = 0; i < aData.size(); i++) {
    memcpy(buffer + lNrBytesCopied, aData.at(i).first, aData.at(i).second);
    lNrBytesCopied += aData.at(i).second;
  }
 
  lNrBytesCopied = 0;
  uint32_t lAddr = aAddr / 2;
 
  while (lNrBytesCopied < lNrBytes) {
    bar2->IPBUS_WRITE_ADDRESS = lAddr;
    char* lSrcPtr = buffer + lNrBytesCopied;
    if ((lNrBytes - lNrBytesCopied) >= 8) {
      bar2->IPBUS_WRITE_DATA.DATA = *(uint64_t*)lSrcPtr;
      lNrBytesCopied += 8;
    } else if ((lNrBytes - lNrBytesCopied) >= 4) {
      bar2->IPBUS_WRITE_DATA.DATA = uint64_t(*(uint32_t*)lSrcPtr);
      lNrBytesCopied += 4;
    }
 
    ++lAddr;
  }
 
  free(allocated);
}

Member Data Documentation

mDeviceId

int uhallibs::Flx::Card::mDeviceId

private

Definition at line 128 of file ProtocolFlx.hpp.

mFd

int uhallibs::Flx::Card::mFd

private

Definition at line 134 of file ProtocolFlx.hpp.

mFlxCard

FlxCard uhallibs::Flx::Card::mFlxCard

private

Definition at line 131 of file ProtocolFlx.hpp.

mIsOpen

bool uhallibs::Flx::Card::mIsOpen

private

Definition at line 132 of file ProtocolFlx.hpp.

mLocked

bool uhallibs::Flx::Card::mLocked

private

Definition at line 135 of file ProtocolFlx.hpp.

mLockMask

u_int uhallibs::Flx::Card::mLockMask

private

Definition at line 129 of file ProtocolFlx.hpp.

mPath

std::string uhallibs::Flx::Card::mPath

private

Definition at line 127 of file ProtocolFlx.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/uhallibs/include/uhallibs/ProtocolFlx.hpp
• /github/workspace/dunedaq/sourcecode/uhallibs/src/ProtocolFlx.cpp