#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.

38{ return mPath; }

◆ haveLock()

bool uhallibs::Axi4Lite::MappedFile::haveLock ( ) const

Definition at line 148 of file ProtocolAxi4Lite.cpp.

148{ 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.

41{ mLength = aLength; }

◆ setPath()

void uhallibs::Axi4Lite::MappedFile::setPath ( const std::string & aPath )

Definition at line 40 of file ProtocolAxi4Lite.cpp.

40{ 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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MappedFile()

◆ ~MappedFile()

Member Function Documentation

◆ close()

◆ createBuffer()

◆ getPath()

◆ haveLock()

◆ lock()

◆ open()

◆ read()

◆ setLength()

◆ setPath()

◆ unlock()

◆ write() [1/3]

◆ write() [2/3]

◆ write() [3/3]

Member Data Documentation

◆ mBar

◆ mBuffer

◆ mBufferSize

◆ mFd

◆ mLength

◆ mLocked

◆ mPath

◆ mProtFlags