Line data    Source code

       1             : #include "tohost_buffer.hpp"
       2             : 
       3           0 : FlxToHostBuffer::FlxToHostBuffer(int dmaid, std::shared_ptr<Device> d)
       4           0 :     : ToHostBuffer(dmaid, d){}
       5             : 
       6             : 
       7           0 : FlxToHostBuffer::~FlxToHostBuffer()
       8             : {
       9           0 :     m_device->dma_stop(m_dmaid);
      10           0 : }
      11             : 
      12           0 : void FlxToHostBuffer::allocate_buffer(size_t size,
      13             :                             const std::string& name,
      14             :                             bool vmem, bool free_previous_cmem)
      15             : {
      16           0 :     m_size = size;
      17           0 :     m_buffer = std::make_unique<CmemBuffer>(size, name, free_previous_cmem);
      18           0 :     m_block_size = m_device->get_block_size();
      19           0 : }
      20             : 
      21             : 
      22           0 : void FlxToHostBuffer::dma_start_continuous()
      23             : {
      24           0 :     m_device->dma_to_host(m_buffer.get(), m_dmaid);
      25           0 :     m_device->dma_set_sw_ptr(m_dmaid, m_buffer->paddr);
      26           0 : }
      27             : 
      28             : 
      29           0 : void FlxToHostBuffer::dma_wait_for_data_irq()
      30             : {
      31           0 :     m_device->irq_wait(m_irq_on_data);
      32           0 : }
      33             : 
      34             : 
      35           0 : size_t FlxToHostBuffer::dma_bytes_available()
      36             : {
      37           0 :     u_long dma_ptr = m_device->dma_get_fw_ptr(m_dmaid);
      38           0 :     if( dma_ptr > m_buffer->pc_ptr ) {
      39           0 :         return dma_ptr - m_buffer->pc_ptr;
      40             :     }
      41           0 :     else if( dma_ptr < m_buffer->pc_ptr ) {
      42           0 :         return m_buffer->size + dma_ptr - m_buffer->pc_ptr;
      43             :     }
      44             :     else { // dma_ptr == buf->pc_ptr
      45           0 :         if( m_device->dma_cmp_even_bits(m_dmaid) ) {
      46             :             return 0; // Buffer empty
      47             :         } else {
      48           0 :             return m_buffer->size; // Buffer full
      49             :         }
      50             :     }
      51             : }
      52             : 
      53             : 
      54           0 : bool FlxToHostBuffer::dma_is_full()
      55             : {
      56           0 :     u_long write_ptr = m_device->dma_get_fw_ptr(m_dmaid);
      57           0 :     u_long read_ptr  = m_buffer->pc_ptr;
      58           0 :     return (write_ptr == read_ptr and not m_device->dma_cmp_even_bits(m_dmaid));
      59             : }
      60             : 
      61             : 
      62           0 : size_t FlxToHostBuffer::dma_bytes_available_nowrap()
      63             : {
      64           0 :     size_t available = dma_bytes_available();
      65           0 :     return MIN(available, m_buffer->pend - m_buffer->pc_ptr);
      66             : }
      67             : 
      68             : 
      69           0 : uint64_t FlxToHostBuffer::dma_get_write_ptr()
      70             : {
      71           0 :     u_long dma_ptr = m_device->dma_get_fw_ptr(m_dmaid);
      72           0 :     return (m_buffer->vaddr + (dma_ptr - m_buffer->paddr));
      73             : }
      74             : 
      75             : 
      76           0 : uint64_t FlxToHostBuffer::dma_get_read_ptr()
      77             : {
      78           0 :     return (m_buffer->vaddr + (m_buffer->pc_ptr - m_buffer->paddr));
      79             : }
      80             : 
      81             : 
      82           0 : uint64_t FlxToHostBuffer::dma_get_write_offset()
      83             : {
      84           0 :     return ( m_device->dma_get_fw_ptr(m_dmaid) - m_buffer->paddr );
      85             : }
      86             : 
      87             : 
      88           0 : uint64_t FlxToHostBuffer::dma_get_read_offset()
      89             : {
      90           0 :     return (m_buffer->pc_ptr - m_buffer->paddr);
      91             : }
      92             : 
      93             : 
      94           0 : void FlxToHostBuffer::dma_set_read_ptr_vaddr(uint64_t v_addr)
      95             : {
      96           0 :     uint64_t pnew = m_buffer->paddr + (v_addr - m_buffer->vaddr);
      97           0 :     m_buffer->pc_ptr = pnew;
      98           0 :     m_device->dma_set_sw_ptr(m_dmaid, pnew);
      99           0 : }
     100             : 
     101             : 
     102           0 : void FlxToHostBuffer::dma_set_read_ptr_paddr(uint64_t p_addr)
     103             : {
     104           0 :     m_buffer->pc_ptr = p_addr;
     105           0 :     m_device->dma_set_sw_ptr(m_dmaid, p_addr);
     106           0 : }
     107             : 
     108             : 
     109           0 : void FlxToHostBuffer::dma_advance_read_ptr(size_t bytes)
     110             : {
     111           0 :     m_buffer->pc_ptr += bytes;
     112           0 :     if(m_buffer->pc_ptr == m_buffer->pend){
     113           0 :         m_buffer->pc_ptr = m_buffer->paddr;
     114             :     }
     115           0 :     m_device->dma_set_sw_ptr(m_dmaid, m_buffer->pc_ptr);
     116           0 : }