Line data    Source code

       1             : #ifndef FELIX_DMA_H_
       2             : #define FELIX_DMA_H_
       3             : 
       4             : #include <string>
       5             : 
       6             : /**
       7             :  * Base class for a FELIX DMA buffer.
       8             :  * The buffer is defined by a physical address (paddr - used by the FELIX card),
       9             :  * a size (size) and end-address (pend).
      10             :  * The physical address is mapped to a virtual address (vaddr) used by software
      11             :  * in user space.
      12             :  * Software and firmware maintain each a read/write address depending on the
      13             :  * data transfer direction. The address managed by software is pc_ptr.
      14             :  * The firmware pointer is read from the card register or is emulated in software
      15             :  * by emu_fw_ptr.
      16             :  * */
      17             : class DmaBuffer {
      18             :     public:
      19             :         uint64_t paddr;
      20             :         uint64_t vaddr;
      21             :         size_t size;
      22             :         uint64_t pend;
      23             : 
      24             :         uint64_t pc_ptr;
      25             :         uint64_t emu_fw_ptr;
      26             : 
      27             :         /**
      28             :          * @brief Constructor for a DMA buffer.
      29             :          * @details All address are initialised to zero.
      30             :          * @param size buffer size.
      31             :          */ 
      32          27 :         explicit DmaBuffer(size_t c) : paddr(0), vaddr(0), size(c), pend(0), pc_ptr(0), emu_fw_ptr(0) {};
      33          27 :         virtual ~DmaBuffer() {};
      34             : 
      35             : };
      36             : 
      37             : /**
      38             :  * DMA buffer allocated by the CMEM driver.
      39             :  * */
      40             : class CmemBuffer : public DmaBuffer {
      41             :     public:
      42             :         int handle;
      43             :         bool free_previous_cmem;
      44             : 
      45             :         /**
      46             :          * @brief Allocate a CMEM buffer
      47             :          * @param size requested buffer size.
      48             :          * @param cmem_name buffer name passed to the CMEM driver.
      49             :          * @param free_previous_cmem let CMEM free an existing buffer with same name if not locked.
      50             :          */ 
      51             :         explicit CmemBuffer(size_t size, const std::string& cmem_name, bool free_previous_cmem = false);
      52             :         ~CmemBuffer();
      53             : 
      54             :         CmemBuffer(const CmemBuffer&) = delete;
      55             :         CmemBuffer& operator=(CmemBuffer&&) = delete;
      56             : 
      57             :         /**
      58             :          * @brief Check if a buffer with the same name is already allocated.
      59             :          * @param cmem_name buffer name passed to the CMEM driver.
      60             :          */ 
      61             :         static bool cmem_buffer_exists(const std::string& cmem_name);
      62             : };
      63             : 
      64             : /**
      65             :  * Buffer allocated in memory to emulate a CMEM DMA buffer.
      66             :  * */
      67             : class VmemBuffer : public DmaBuffer {
      68             :     public:
      69             :         /**
      70             :          * @brief Allocate a buffer in memory
      71             :          * @param size requested buffer size.
      72             :          */ 
      73             :         explicit VmemBuffer(size_t size);
      74             :         ~VmemBuffer();
      75             : 
      76             :         VmemBuffer(const VmemBuffer&) = delete;
      77             :         VmemBuffer& operator=(VmemBuffer&&) = delete;
      78             : 
      79             :     private:
      80             :         void* ptr;
      81             : };
      82             : 
      83             : #endif /* FELIX_DMA_H_ */