uhallibs::Axi4Lite::MappedFile Class Reference

#include <ProtocolAxi4Lite.hpp>

Public Member Functions
	MappedFile (const std::string &aPath, size_t aLength, int aProtFlags=PROT_WRITE)
	~MappedFile ()
const std::string &	getPath () const
void	setPath (const std::string &aPath)
void	setLength (size_t)
void	open ()
	Open bus file and map it to memory.
void	close ()
	Unmap and close file.
void	createBuffer (const size_t aNrBytes)
	Create a local buffer.
void	read (const uint32_t aAddr, const uint32_t aNrWords, std::vector< uint32_t > &aValues)
void	write (const uint32_t aAddr, const std::vector< uint32_t > &aValues)
void	write (const uint32_t aAddr, const uint8_t *const aPtr, const size_t aNrBytes)
void	write (const uint32_t aAddr, const std::vector< std::pair< const uint8_t *, size_t > > &aData)
bool	haveLock () const
void	lock ()
void	unlock ()

Private Attributes
std::string	mPath
int	mFd
uint32_t *	mBar
size_t	mLength
int	mProtFlags
bool	mLocked
size_t	mBufferSize
char *	mBuffer

Detailed Description

Definition at line 95 of file ProtocolAxi4Lite.hpp.

Constructor & Destructor Documentation

MappedFile()

uhallibs::Axi4Lite::MappedFile::MappedFile	(	const std::string &	aPath,
		size_t	aLength,
		int	aProtFlags = PROT_WRITE )

Definition at line 22 of file ProtocolAxi4Lite.cpp.

  : mPath(aPath)
  , mFd(-1)
  , mBar(nullptr)
  , mLength(aLength)
  , mProtFlags(aProtFlags)
  , mLocked(false)
  , mBufferSize(0)
  , mBuffer(nullptr)
{
}

~MappedFile()

uhallibs::Axi4Lite::MappedFile::~MappedFile

(

)

Definition at line 34 of file ProtocolAxi4Lite.cpp.

{
  if (mBuffer != nullptr)
    free(mBuffer);
  close();
}

Member Function Documentation

close()

void uhallibs::Axi4Lite::MappedFile::close

(

)

Unmap and close file.

Definition at line 74 of file ProtocolAxi4Lite.cpp.

{
  if (mBar != nullptr)
    munmap(mBar, mLength);
  mBar = nullptr;
 
  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)));
  }
}

createBuffer()

void uhallibs::Axi4Lite::MappedFile::createBuffer

(

const size_t

aNrBytes

)

Create a local buffer.

Definition at line 97 of file ProtocolAxi4Lite.cpp.

{
  if (mBuffer != NULL) {
    if (mBufferSize >= aNrBytes)
      return;
    else {
      free(mBuffer);
      mBuffer = NULL;
      mBufferSize = 0;
    }
  }
 
  posix_memalign((void**)&mBuffer, 4096 /*alignment*/, aNrBytes + 4096);
  if (mBuffer == NULL) {
    exception::Axi4LiteCommunicationError lExc;
    log(lExc, "Failed to allocate ", Integer(aNrBytes + 4096), " bytes in Axi4Lite::MappedFile::createBuffer");
    throw lExc;
  }
 
  mBufferSize = aNrBytes + 4096;
}

getPath()

const std::string & uhallibs::Axi4Lite::MappedFile::getPath

(

)

const

Definition at line 42 of file ProtocolAxi4Lite.cpp.

{
  return mPath;
}

haveLock()

bool uhallibs::Axi4Lite::MappedFile::haveLock

(

)

const

Definition at line 183 of file ProtocolAxi4Lite.cpp.

{
  return mLocked;
}

lock()

void uhallibs::Axi4Lite::MappedFile::lock

(

)

Definition at line 189 of file ProtocolAxi4Lite.cpp.

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

open()

void uhallibs::Axi4Lite::MappedFile::open

(

)

Open bus file and map it to memory.

Definition at line 59 of file ProtocolAxi4Lite.cpp.

{
  if (mBar != nullptr)
    return;
 
  mFd = ::open(mPath.c_str(), (mProtFlags & PROT_WRITE) ? O_RDWR : O_RDONLY);
  if (mFd < 0) {
    return;
  }
 
  void* lBar = mmap(nullptr, 4 * mLength, mProtFlags, MAP_SHARED, mFd, 0);
  mBar = (lBar == MAP_FAILED ? nullptr : (uint32_t*)lBar);
}

read()

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

Definition at line 120 of file ProtocolAxi4Lite.cpp.

{
  if (mBar == nullptr)
    open();
 
  for (size_t i(0); i < aNrWords; ++i) {
    aValues.push_back(le32toh(mBar[aAddr + i]));
  }
}

setLength()

void uhallibs::Axi4Lite::MappedFile::setLength

(

size_t

aLength

)

Definition at line 53 of file ProtocolAxi4Lite.cpp.

{
  mLength = aLength;
}

setPath()

void uhallibs::Axi4Lite::MappedFile::setPath

(

const std::string &

aPath

)

Definition at line 48 of file ProtocolAxi4Lite.cpp.

{
  mPath = aPath;
}

unlock()

void uhallibs::Axi4Lite::MappedFile::unlock

(

)

Definition at line 206 of file ProtocolAxi4Lite.cpp.

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

write() [1/3]

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

Definition at line 152 of file ProtocolAxi4Lite.cpp.

{
  if (mBar == nullptr)
    open();
 
  size_t lNrBytes = 0;
  for (size_t i = 0; i < aData.size(); i++)
    lNrBytes += aData.at(i).second;
 
  assert((lNrBytes % 4) == 0);
  size_t lNrWords = lNrBytes / 4;
 
  createBuffer(lNrBytes);
 
  size_t k(0);
  for (size_t i = 0; i < aData.size(); ++i) {
    for (size_t j = 0; j < aData.at(i).second; ++j) {
      mBuffer[k] = aData.at(i).first[j];
      ++k;
    }
  }
 
  auto mBuffer32b = reinterpret_cast<const uint32_t*>(mBuffer);
 
  for (size_t i(0); i < lNrWords; ++i) {
    mBar[aAddr + i] = htole32(mBuffer32b[i]);
  }
  // std::memcpy(mBar + aAddr, mBuffer, lNrBytes);
}

write() [2/3]

void uhallibs::Axi4Lite::MappedFile::write	(	const uint32_t	aAddr,
		const std::vector< uint32_t > &	aValues )

Definition at line 131 of file ProtocolAxi4Lite.cpp.

{
  write(aAddr, reinterpret_cast<const uint8_t*>(aValues.data()), 4 * aValues.size());
}

write() [3/3]

void uhallibs::Axi4Lite::MappedFile::write	(	const uint32_t	aAddr,
		const uint8_t *const	aPtr,
		const size_t	aNrBytes )

Definition at line 137 of file ProtocolAxi4Lite.cpp.

{
  if (mBar == nullptr)
    open();
 
  assert((aNrBytes % 4) == 0);
  uint32_t lNrWordsData = aNrBytes / 4;
 
  auto lPtr32 = reinterpret_cast<const uint32_t*>(aPtr);
  for (size_t i(0); i < lNrWordsData; ++i) {
    mBar[aAddr + i] = lPtr32[i];
  }
}

Member Data Documentation

mBar

uint32_t* uhallibs::Axi4Lite::MappedFile::mBar

private

Definition at line 132 of file ProtocolAxi4Lite.hpp.

mBuffer

char* uhallibs::Axi4Lite::MappedFile::mBuffer

private

Definition at line 137 of file ProtocolAxi4Lite.hpp.

mBufferSize

size_t uhallibs::Axi4Lite::MappedFile::mBufferSize

private

Definition at line 136 of file ProtocolAxi4Lite.hpp.

mFd

int uhallibs::Axi4Lite::MappedFile::mFd

private

Definition at line 131 of file ProtocolAxi4Lite.hpp.

mLength

size_t uhallibs::Axi4Lite::MappedFile::mLength

private

Definition at line 133 of file ProtocolAxi4Lite.hpp.

mLocked

bool uhallibs::Axi4Lite::MappedFile::mLocked

private

Definition at line 135 of file ProtocolAxi4Lite.hpp.

mPath

std::string uhallibs::Axi4Lite::MappedFile::mPath

private

Definition at line 130 of file ProtocolAxi4Lite.hpp.

mProtFlags

int uhallibs::Axi4Lite::MappedFile::mProtFlags

private

Definition at line 134 of file ProtocolAxi4Lite.hpp.

---

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

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