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 97 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 23 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 33 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 55 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 70 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 38 of file ProtocolAxi4Lite.cpp.

{ return mPath; }

haveLock()

bool uhallibs::Axi4Lite::MappedFile::haveLock

(

)

const

Definition at line 148 of file ProtocolAxi4Lite.cpp.

{ return mLocked; }

lock()

void uhallibs::Axi4Lite::MappedFile::lock

(

)

Definition at line 150 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 43 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 92 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 41 of file ProtocolAxi4Lite.cpp.

{ mLength = aLength; }

setPath()

void uhallibs::Axi4Lite::MappedFile::setPath

(

const std::string &

aPath

)

Definition at line 40 of file ProtocolAxi4Lite.cpp.

{ mPath = aPath; }

unlock()

void uhallibs::Axi4Lite::MappedFile::unlock

(

)

Definition at line 160 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 119 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 101 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 106 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 137 of file ProtocolAxi4Lite.hpp.

mBuffer

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

private

Definition at line 142 of file ProtocolAxi4Lite.hpp.

mBufferSize

size_t uhallibs::Axi4Lite::MappedFile::mBufferSize

private

Definition at line 141 of file ProtocolAxi4Lite.hpp.

mFd

int uhallibs::Axi4Lite::MappedFile::mFd

private

Definition at line 136 of file ProtocolAxi4Lite.hpp.

mLength

size_t uhallibs::Axi4Lite::MappedFile::mLength

private

Definition at line 138 of file ProtocolAxi4Lite.hpp.

mLocked

bool uhallibs::Axi4Lite::MappedFile::mLocked

private

Definition at line 140 of file ProtocolAxi4Lite.hpp.

mPath

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

private

Definition at line 135 of file ProtocolAxi4Lite.hpp.

mProtFlags

int uhallibs::Axi4Lite::MappedFile::mProtFlags

private

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