AxiStreamDma.h

Go to the documentation of this file.

 
#ifndef __ROGUE_HARDWARE_AXI_AXI_STREAM_DMA_H__
#define __ROGUE_HARDWARE_AXI_AXI_STREAM_DMA_H__
#include "rogue/Directives.h"
 
#include <stdint.h>
 
#include <map>
#include <memory>
#include <string>
#include <thread>
 
#include "rogue/Logging.h"
#include "rogue/interfaces/stream/Master.h"
#include "rogue/interfaces/stream/Slave.h"
 
namespace rogue {
namespace hardware {
namespace axi {
 
class AxiStreamDmaShared {
  public:
    explicit AxiStreamDmaShared(std::string path);
 
    // Shared driver file descriptor used for DMA buffer mapping.
    int32_t fd;
 
    // Device path.
    std::string path;
 
    // Number of active AxiStreamDma instances using this descriptor.
    int32_t openCount;
 
    // Pointer array to mapped DMA buffers for zero-copy mode.
    void** rawBuff;
 
    // Number of mapped DMA buffers.
    uint32_t bCount;
 
    // DMA buffer size in bytes.
    uint32_t bSize;
 
    // Zero-copy mode enabled for this path.
    bool zCopyEn;
};
 
typedef std::shared_ptr<rogue::hardware::axi::AxiStreamDmaShared> AxiStreamDmaSharedPtr;
 
class AxiStreamDma : public rogue::interfaces::stream::Master, public rogue::interfaces::stream::Slave {
    // Shared mapped-buffer descriptor cache by device path.
    static std::map<std::string, std::shared_ptr<rogue::hardware::axi::AxiStreamDmaShared> > sharedBuffers_;
 
    // Maximum number of buffers to receive in one DMA call.
    static const uint32_t RxBufferCount = 100;
 
    // Shared descriptor state for this path.
    std::shared_ptr<rogue::hardware::axi::AxiStreamDmaShared> desc_;
 
    // Process-local descriptor for TX/RX operations and dest mask programming.
    int32_t fd_;
 
    // Destination selector used when transmitting frames.
    uint32_t dest_;
 
    // TX/alloc select timeout.
    struct timeval timeout_;
 
    // SSI flag handling enable.
    bool enSsi_;
 
    // RX worker thread control.
    std::thread* thread_;
    bool threadEn_;
 
    // Logger instance.
    std::shared_ptr<rogue::Logging> log_;
 
    // RX worker thread entry point.
    void runThread(std::weak_ptr<int>);
 
    // Deferred DMA buffer return queue.
    rogue::Queue<uint32_t> retQueue_;
 
    // Threshold for draining return queue.
    uint32_t retThold_;
 
    // Opens/reuses shared DMA mapping state for a device path.
    static std::shared_ptr<rogue::hardware::axi::AxiStreamDmaShared> openShared(std::string path,
                                                                                std::shared_ptr<rogue::Logging> log);
 
    // Closes shared DMA mapping state when last user exits.
    static void closeShared(std::shared_ptr<rogue::hardware::axi::AxiStreamDmaShared>);
 
  public:
    static std::shared_ptr<rogue::hardware::axi::AxiStreamDma> create(std::string path, uint32_t dest, bool ssiEnable);
 
    static void zeroCopyDisable(std::string path);
 
    static void setup_python();
 
    AxiStreamDma(std::string path, uint32_t dest, bool ssiEnable);
 
    ~AxiStreamDma();
 
    void stop();
 
    void setTimeout(uint32_t timeout);
 
    void setDriverDebug(uint32_t level);
 
    void dmaAck();
 
    std::shared_ptr<rogue::interfaces::stream::Frame> acceptReq(uint32_t size, bool zeroCopyEn);
 
    void acceptFrame(std::shared_ptr<rogue::interfaces::stream::Frame> frame);
 
    void retBuffer(uint8_t* data, uint32_t meta, uint32_t rawSize);
 
    std::string getGitVersion();
 
    uint32_t getApiVersion();
 
    uint32_t getBuffSize();
 
    uint32_t getRxBuffCount();
 
    uint32_t getRxBuffinUserCount();
 
    uint32_t getRxBuffinHwCount();
 
    uint32_t getRxBuffinPreHwQCount();
 
    uint32_t getRxBuffinSwQCount();
 
    uint32_t getRxBuffMissCount();
 
    uint32_t getTxBuffCount();
 
    uint32_t getTxBuffinUserCount();
 
    uint32_t getTxBuffinHwCount();
 
    uint32_t getTxBuffinPreHwQCount();
 
    uint32_t getTxBuffinSwQCount();
 
    uint32_t getTxBuffMissCount();
};
 
typedef std::shared_ptr<rogue::hardware::axi::AxiStreamDma> AxiStreamDmaPtr;
 
}  // namespace axi
}  // namespace hardware
};  // namespace rogue
 
#endif