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 110 of file ProtocolFlx.hpp.

Constructor & Destructor Documentation

Card()

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

Definition at line 94 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 123 of file ProtocolFlx.cpp.

               {
}

Member Function Documentation

close()

void uhallibs::Flx::Card::close

(

)

Definition at line 151 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 81 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 173 of file ProtocolFlx.cpp.

                               {
  return mDeviceId;
}

getPath()

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

(

)

const

Definition at line 168 of file ProtocolFlx.cpp.

                                        {
  return mPath;
}

haveLock()

bool uhallibs::Flx::Card::haveLock

(

)

const

Definition at line 257 of file ProtocolFlx.cpp.

{ return mLocked; }

lock()

void uhallibs::Flx::Card::lock

(

)

Definition at line 260 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 128 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 178 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 270 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 206 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 139 of file ProtocolFlx.hpp.

mFd

int uhallibs::Flx::Card::mFd

private

Definition at line 145 of file ProtocolFlx.hpp.

mFlxCard

FlxCard uhallibs::Flx::Card::mFlxCard

private

Definition at line 142 of file ProtocolFlx.hpp.

mIsOpen

bool uhallibs::Flx::Card::mIsOpen

private

Definition at line 143 of file ProtocolFlx.hpp.

mLocked

bool uhallibs::Flx::Card::mLocked

private

Definition at line 146 of file ProtocolFlx.hpp.

mLockMask

u_int uhallibs::Flx::Card::mLockMask

private

Definition at line 140 of file ProtocolFlx.hpp.

mPath

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

private

Definition at line 138 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