uart_circular_dma_rx_model.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "libxr_assert.hpp"
#include "libxr_rw.hpp"
 
namespace LibXR
{
 
class UartCircularDmaRxModel
{
 public:
  explicit UartCircularDmaRxModel(RawData storage) : storage_(storage) {}
 
  template <typename Backend>
  void Start(Backend& backend)
  {
    ResetPosition();
    backend.StartCircularDmaRx(Buffer(), BufferSize());
  }
 
  template <typename Backend>
  void OnDataAvailable(Backend& backend, ReadPort& port, bool in_isr)
  {
    uint8_t* const buffer = Buffer();
    const size_t capacity = BufferSize();
    const size_t remaining = backend.GetCircularDmaRxRemaining();
    if (remaining > capacity)
    {
      ASSERT(false);
      return;
    }
 
    const size_t current_position = capacity - remaining;
    backend.PrepareCircularDmaRxForCpu(buffer, capacity);
 
    if (current_position == last_position_)
    {
      return;
    }
 
    if (current_position > last_position_)
    {
      (void)port.queue_data_->PushBatch(&buffer[last_position_],
                                        current_position - last_position_);
    }
    else
    {
      (void)port.queue_data_->PushBatch(&buffer[last_position_],
                                        capacity - last_position_);
      (void)port.queue_data_->PushBatch(buffer, current_position);
    }
 
    last_position_ = current_position;
    port.ProcessPendingReads(in_isr);
  }
 
  void ResetPosition() { last_position_ = 0U; }
 
  [[nodiscard]] uint8_t* Buffer() const { return static_cast<uint8_t*>(storage_.addr_); }
 
  [[nodiscard]] size_t BufferSize() const { return storage_.size_; }
 
  [[nodiscard]] size_t LastPosition() const { return last_position_; }
 
 private:
  RawData storage_;
  size_t last_position_ = 0U;
};
 
}  // namespace LibXR