45 #include <boost/python.hpp>
46namespace bp = boost::python;
49std::map<std::string, std::shared_ptr<rha::AxiStreamDmaShared> > rha::AxiStreamDma::sharedBuffers_;
54rha::AxiStreamDmaShared::AxiStreamDmaShared(std::string path) {
73 std::map<std::string, rha::AxiStreamDmaSharedPtr>::iterator it;
77 if ((it = sharedBuffers_.find(path)) != sharedBuffers_.end()) {
79 log->debug(
"Reusing existing shared file descriptor for %s", path.c_str());
84 log->debug(
"Shared file descriptor already opened for %s", path.c_str());
95 log->debug(
"Zero copy is disabled. Not Mapping Buffers for %s", path.c_str());
104 ret = std::make_shared<rha::AxiStreamDmaShared>(path);
105 log->debug(
"Opening new shared file descriptor for %s", path.c_str());
109 if ((ret->fd = ::open(path.c_str(), O_RDWR)) < 0)
128 R
"(Bad kernel driver version detected. Please re-compile kernel driver.
129 Note that aes-stream-driver (v5.15.2 or earlier) and rogue (v5.11.1 or earlier) are compatible with the 32-bit address API.
130 To use later versions (64-bit address API),, you will need to upgrade both rogue and aes-stream-driver at the same time to:
131 \t\taes-stream-driver = v5.16.0 (or later)
132 \t\trogue = v5.13.0 (or later))"));
140 "AxiStreamDma::openShared",
141 "Rogue DmaDriver.h API Version (DMA_VERSION) does not match the aes-stream-driver API version"));
146 ret->rawBuff =
dmaMapDma(ret->fd, &(ret->bCount), &(ret->bSize));
147 if (ret->rawBuff == NULL) {
160 "AxiStreamDma::openShared",
161 "Failed to map dma buffers. Increase vm map limit to : sudo sysctl -w vm.max_map_count=%i",
164 log->debug(
"Mapped buffers. bCount = %i, bSize=%i for %s", ret->bCount, ret->bSize, path.c_str());
168 sharedBuffers_.insert(std::pair<std::string, rha::AxiStreamDmaSharedPtr>(path, ret));
178 if (desc->openCount == 0) {
179 if (desc->rawBuff != NULL) {
187 if (desc->fd != -1) {
193 desc->rawBuff = NULL;
198rha::AxiStreamDmaPtr rha::AxiStreamDma::create(std::string path, uint32_t dest,
bool ssiEnable) {
203void rha::AxiStreamDma::zeroCopyDisable(std::string path) {
206 std::map<std::string, rha::AxiStreamDmaSharedPtr>::iterator it;
209 if ((it = sharedBuffers_.find(path)) != sharedBuffers_.end())
211 "zeroCopyDisable can't be called twice or after a device has been opened"));
215 ret->zCopyEn =
false;
217 sharedBuffers_.insert(std::pair<std::string, rha::AxiStreamDmaSharedPtr>(path, ret));
221rha::AxiStreamDma::AxiStreamDma(std::string path, uint32_t dest,
bool ssiEnable) {
229 std::shared_ptr<int> scopePtr = std::make_shared<int>(0);
238 desc_ = openShared(path, log_);
241 if ((fd_ = ::open(path.c_str(), O_RDWR)) < 0) {
258 if (desc_->rawBuff == NULL) {
262 if (desc_->bCount >= 1000) retThold_ = 80;
273 "Failed to open device file %s with dest 0x%" PRIx32
274 "! Another process may already have it open!",
281 thread_ = std::make_unique<std::thread>(&rha::AxiStreamDma::runThread,
this, std::weak_ptr<int>(scopePtr));
292 pthread_setname_np(thread_->native_handle(),
"AxiStreamDma");
297rha::AxiStreamDma::~AxiStreamDma() {
306void rha::AxiStreamDma::stop() {
319 if (thread_ && thread_->joinable()) {
328 std::lock_guard<std::mutex> lock(fdMtx_);
337void rha::AxiStreamDma::setTimeout(uint32_t timeout) {
339 div_t divResult = div(timeout, 1000000);
340 timeout_.tv_sec = divResult.quot;
341 timeout_.tv_usec = divResult.rem;
346void rha::AxiStreamDma::setDriverDebug(uint32_t level) {
351void rha::AxiStreamDma::dmaAck() {
356ris::FramePtr rha::AxiStreamDma::acceptReq(uint32_t size,
bool zeroCopyEn) {
368 if (!desc_ || fd_ < 0)
370 "instance has been stopped or did not finish construction");
373 if (size > desc_->bSize)
374 buffSize = desc_->bSize;
379 if (zeroCopyEn ==
false || desc_->rawBuff == NULL) {
380 frame = reqLocalFrame(size,
false);
387 frame = ris::Frame::create();
391 while (alloc < size) {
402 "AxiStreamDma::acceptReq",
403 "fd_=%d invalid; instance was stop()'d or never finished construction",
406 pfd.events = POLLOUT;
410 int rc = poll(&pfd, 1, (timeout_.tv_sec * 1000) + ((timeout_.tv_usec + 999) / 1000));
414 if (rc > 0 && (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)))
416 "AxiStreamDma::acceptReq",
417 "poll() reported fd error revents=0x%x; fd may be closed or in error state",
419 if (rc <= 0 || !(pfd.revents & POLLOUT)) {
420 log_->critical(
"AxiStreamDma::acceptReq: Timeout waiting for outbound buffer after %" PRIuLEAST32
421 ".%" PRIuLEAST32
" seconds! May be caused by outbound back pressure.",
433 buff = createBuffer(desc_->rawBuff[res], 0x80000000 | res, buffSize, desc_->bSize);
434 frame->appendBuffer(buff);
454 if (!desc_ || fd_ < 0)
456 "instance has been stopped or did not finish construction");
463 if (frame->getError()) {
464 log_->warning(
"Dumping errored frame");
469 ris::Frame::BufferIterator it;
470 for (it = frame->beginBuffer(); it != frame->endBuffer(); ++it) {
474 if (it == frame->beginBuffer()) {
475 fuser = frame->getFirstUser();
476 if (enSsi_) fuser |= 0x2;
482 if (it == (frame->endBuffer() - 1)) {
484 luser = frame->getLastUser();
493 meta = (*it)->getMeta();
496 if ((meta & 0x80000000) != 0) {
500 if ((meta & 0x40000000) == 0) {
512 (*it)->setMeta(meta);
527 "AxiStreamDma::acceptFrame",
528 "fd_=%d invalid; instance was stop()'d or never finished construction",
531 pfd.events = POLLOUT;
535 int rc = poll(&pfd, 1, (timeout_.tv_sec * 1000) + ((timeout_.tv_usec + 999) / 1000));
539 if (rc > 0 && (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)))
541 "AxiStreamDma::acceptFrame",
542 "poll() reported fd error revents=0x%x; fd may be closed or in error state",
544 if (rc <= 0 || !(pfd.revents & POLLOUT)) {
545 log_->critical(
"AxiStreamDma::acceptFrame: Timeout waiting for outbound write after %" PRIuLEAST32
546 ".%" PRIuLEAST32
" seconds! May be caused by outbound back pressure.",
562 if (emptyFrame) frame->clear();
566void rha::AxiStreamDma::retBuffer(uint8_t* data, uint32_t meta, uint32_t size) {
570 if ((meta & 0x80000000) != 0) {
575 if ((meta & 0x40000000) == 0) {
576 std::lock_guard<std::mutex> lock(fdMtx_);
577 if (fd_ >= 0 &&
dmaRetIndex(fd_, meta & 0x3FFFFFFF) < 0)
578 throw(
rogue::GeneralError(
"AxiStreamDma::retBuffer",
"AXIS Return Buffer Call Failed!!!!"));
584 Pool::retBuffer(data, meta, size);
589void rha::AxiStreamDma::runThread(std::weak_ptr<int> lockPtr) {
591 uint32_t meta[RxBufferCount];
592 uint32_t rxFlags[RxBufferCount];
593 uint32_t rxError[RxBufferCount];
594 int32_t rxSize[RxBufferCount];
609 while (!lockPtr.expired())
continue;
616 ris::Pool::shared_from_this();
618 }
catch (
const std::bad_weak_ptr&) {
619 std::this_thread::sleep_for(std::chrono::milliseconds(1));
622 if (!threadEn_)
return;
627 frame = ris::Frame::create();
636 log_->error(
"AxiStreamDma::runThread: fd_ value %d invalid; exiting worker", fd_);
645 if (poll(&pfd, 1, 1) > 0) {
649 if (pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
650 log_->error(
"AxiStreamDma::runThread: poll reported fd error revents=0x%x; exiting worker",
655 if (!(pfd.revents & POLLIN))
continue;
657 if (desc_->rawBuff == NULL) {
659 buff[0] = allocBuffer(desc_->bSize, NULL);
662 rxSize[0] =
dmaRead(fd_, buff[0]->begin(), buff[0]->getAvailable(), rxFlags, rxError, NULL);
671 rxCount =
dmaReadBulkIndex(fd_, RxBufferCount, rxSize, meta, rxFlags, rxError, NULL);
674 for (x = 0; x < rxCount; x++)
675 buff[x] = createBuffer(desc_->rawBuff[meta[x]], 0x80000000 | meta[x], desc_->bSize, desc_->bSize);
683 log_->error(
"AxiStreamDma::runThread: DMA read failed (ret=%" PRId32
"); exiting worker", rxCount);
689 for (x = 0; x < rxCount; x++) {
694 buff[x]->setPayload(rxSize[x]);
696 error = frame->getError();
699 error |= (rxError[x] & 0xFF);
702 if (frame->isEmpty()) frame->setFirstUser(fuser & 0xFF);
706 frame->setLastUser(luser & 0xFF);
707 if (enSsi_ && ((luser & 0x1) != 0)) error |= 0x80;
710 frame->setError(error);
711 frame->appendBuffer(buff[x]);
717 frame = ris::Frame::create();
725std::string rha::AxiStreamDma::getGitVersion() {
730uint32_t rha::AxiStreamDma::getApiVersion() {
735uint32_t rha::AxiStreamDma::getBuffSize() {
740uint32_t rha::AxiStreamDma::getRxBuffCount() {
745uint32_t rha::AxiStreamDma::getRxBuffinUserCount() {
750uint32_t rha::AxiStreamDma::getRxBuffinHwCount() {
755uint32_t rha::AxiStreamDma::getRxBuffinPreHwQCount() {
760uint32_t rha::AxiStreamDma::getRxBuffinSwQCount() {
765uint32_t rha::AxiStreamDma::getRxBuffMissCount() {
770uint32_t rha::AxiStreamDma::getTxBuffCount() {
775uint32_t rha::AxiStreamDma::getTxBuffinUserCount() {
780uint32_t rha::AxiStreamDma::getTxBuffinHwCount() {
785uint32_t rha::AxiStreamDma::getTxBuffinPreHwQCount() {
790uint32_t rha::AxiStreamDma::getTxBuffinSwQCount() {
795uint32_t rha::AxiStreamDma::getTxBuffMissCount() {
799void rha::AxiStreamDma::setup_python() {
802 bp::class_<rha::AxiStreamDma, rha::AxiStreamDmaPtr, bp::bases<ris::Master, ris::Slave>, boost::noncopyable>(
804 bp::init<std::string, uint32_t, bool>())
805 .def(
"setDriverDebug", &rha::AxiStreamDma::setDriverDebug)
806 .def(
"dmaAck", &rha::AxiStreamDma::dmaAck)
807 .def(
"setTimeout", &rha::AxiStreamDma::setTimeout)
808 .def(
"getGitVersion", &rha::AxiStreamDma::getGitVersion)
809 .def(
"getApiVersion", &rha::AxiStreamDma::getApiVersion)
810 .def(
"getBuffSize", &rha::AxiStreamDma::getBuffSize)
811 .def(
"getRxBuffCount", &rha::AxiStreamDma::getRxBuffCount)
812 .def(
"getRxBuffinUserCount", &rha::AxiStreamDma::getRxBuffinUserCount)
813 .def(
"getRxBuffinHwCount", &rha::AxiStreamDma::getRxBuffinHwCount)
814 .def(
"getRxBuffinPreHwQCount", &rha::AxiStreamDma::getRxBuffinPreHwQCount)
815 .def(
"getRxBuffinSwQCount", &rha::AxiStreamDma::getRxBuffinSwQCount)
816 .def(
"getRxBuffMissCount", &rha::AxiStreamDma::getRxBuffMissCount)
817 .def(
"getTxBuffCount", &rha::AxiStreamDma::getTxBuffCount)
818 .def(
"getTxBuffinUserCount", &rha::AxiStreamDma::getTxBuffinUserCount)
819 .def(
"getTxBuffinHwCount", &rha::AxiStreamDma::getTxBuffinHwCount)
820 .def(
"getTxBuffinPreHwQCount", &rha::AxiStreamDma::getTxBuffinPreHwQCount)
821 .def(
"getTxBuffinSwQCount", &rha::AxiStreamDma::getTxBuffinSwQCount)
822 .def(
"getTxBuffMissCount", &rha::AxiStreamDma::getTxBuffMissCount)
823 .def(
"zeroCopyDisable", &rha::AxiStreamDma::zeroCopyDisable);
825 bp::implicitly_convertible<rha::AxiStreamDmaPtr, ris::MasterPtr>();
826 bp::implicitly_convertible<rha::AxiStreamDmaPtr, ris::SlavePtr>();
static std::mutex sharedBuffersMtx
static uint32_t axisGetLuser(uint32_t flags)
Extracts last-user flag from packed AXIS flags.
static uint32_t axisSetFlags(uint32_t fuser, uint32_t luser, uint32_t cont)
Packs AXIS first-user, last-user, and continuation bits.
static uint32_t axisGetFuser(uint32_t flags)
Extracts first-user flag from packed AXIS flags.
static void axisReadAck(int32_t fd)
Issues AXIS read-acknowledge ioctl command.
static uint32_t axisGetCont(uint32_t flags)
Extracts continuation flag from packed AXIS flags.
static std::string dmaGetGitVersion(int32_t fd)
Get the DMA Driver's Git Version.
static ssize_t dmaGetTxBuffinPreHwQCount(int32_t fd)
Get the transmit buffer count in pre-hardware queue.
static ssize_t dmaGetTxBuffCount(int32_t fd)
Get the transmit buffer count.
static ssize_t dmaGetTxBuffMissCount(int32_t fd)
Get the transmit buffer missing count.
static ssize_t dmaGetRxBuffinHwCount(int32_t fd)
Get the receive buffer count in hardware.
static ssize_t dmaGetApiVersion(int32_t fd)
Get API version of the DMA driver.
static ssize_t dmaWriteIndex(int32_t fd, uint32_t index, size_t size, uint32_t flags, uint32_t dest)
Writes data to a DMA channel using an index.
static void dmaInitMaskBytes(uint8_t *mask)
Initialize DMA mask byte array.
static void dmaAddMaskBytes(uint8_t *mask, uint32_t dest)
Add a destination to the DMA mask byte array.
static ssize_t dmaReadBulkIndex(int32_t fd, uint32_t count, int32_t *ret, uint32_t *index, uint32_t *flags, uint32_t *error, uint32_t *dest)
Receive frame and access memory-mapped buffer.
static ssize_t dmaSetMaskBytes(int32_t fd, uint8_t *mask)
Set mask byte array to the driver.
static ssize_t dmaGetRxBuffinUserCount(int32_t fd)
Get the receive buffer count in user.
static ssize_t dmaGetTxBuffinHwCount(int32_t fd)
Get the transmit buffer count in hardware.
static ssize_t dmaGetBuffSize(int32_t fd)
Get the buffer size.
static ssize_t dmaGetRxBuffinSwQCount(int32_t fd)
Get the receive buffer count in software queue.
static ssize_t dmaGetRxBuffCount(int32_t fd)
Get the receive buffer count.
static int32_t dmaGetIndex(int32_t fd)
Get the current write buffer index.
static ssize_t dmaGetRxBuffinPreHwQCount(int32_t fd)
Get the receive buffer count in pre-hardware queue.
static ssize_t dmaRetIndex(int32_t fd, uint32_t index)
Post an index back to the DMA.
static ssize_t dmaSetDebug(int32_t fd, uint32_t level)
Set debugging level for DMA operations.
static ssize_t dmaGetTxBuffinSwQCount(int32_t fd)
Get the transmit buffer count in software queue.
static ssize_t dmaGetBuffCount(int32_t fd)
Get the buffer count.
static ssize_t dmaCheckVersion(int32_t fd)
Check API version of the DMA driver.
static void ** dmaMapDma(int32_t fd, uint32_t *count, uint32_t *size)
Map user space to DMA buffers.
static ssize_t dmaUnMapDma(int32_t fd, void **buffer)
Unmap user space from DMA buffers.
static ssize_t dmaRead(int32_t fd, void *buf, size_t maxSize, uint32_t *flags, uint32_t *error, uint32_t *dest)
Receive Frame.
static ssize_t dmaGetTxBuffinUserCount(int32_t fd)
Get the transmit buffer count in user.
static ssize_t dmaWrite(int32_t fd, const void *buf, size_t size, uint32_t flags, uint32_t dest)
Writes data to a DMA channel.
static ssize_t dmaGetRxBuffMissCount(int32_t fd)
Get the receive buffer missing count.
Generic Rogue exception type.
static GeneralError create(std::string src, const char *fmt,...)
Creates a formatted error instance.
RAII helper that releases the Python GIL for a scope.
static std::shared_ptr< rogue::Logging > create(const std::string &name, bool quiet=false)
Creates a logger instance.
std::shared_ptr< rogue::hardware::axi::AxiStreamDma > AxiStreamDmaPtr
std::shared_ptr< rogue::hardware::axi::AxiStreamDmaShared > AxiStreamDmaSharedPtr
std::shared_ptr< rogue::interfaces::stream::Buffer > BufferPtr
Shared pointer alias for Buffer.
std::shared_ptr< rogue::interfaces::stream::Frame > FramePtr
Shared pointer alias for Frame.
std::shared_ptr< rogue::interfaces::stream::FrameLock > FrameLockPtr
Shared pointer alias for FrameLock.
std::shared_ptr< rogue::Logging > LoggingPtr
Shared pointer alias for Logging.
void defaultTimeout(struct timeval &tout)
Returns Rogue default timeout as a timeval.