FpgaManager_Interfaces.h

#pragma once

// ================================================================================
// PUBLIC INCLUDES
// ================================================================================

#include "FpgaManager_Types.h"
#include "FpgaManager_Config.h"

#include <cstdint>
#include <functional>
#include <memory>
#include <array>


// ================================================================================
// NAMESPACE
// ================================================================================

namespace enclustra {
namespace fpgamanager {

// ================================================================================
// TYPES
// ================================================================================     

enum class StreamType
{
        ByteStream,
        FrameBased,
};

enum class StreamDirection
{
        Bidirectional,
        Downstream,
        Upstream,
};

// ================================================================================
// INTERFACES
// ================================================================================     

struct ISystem
{
  typedef types::Version<uint8_t, 2> FpgaManagerVersion_t;

  virtual ~ISystem() = default;

  virtual FpgaManagerVersion_t GetSwVersion() = 0;

  virtual std::string GetErrorTrace() = 0;

  virtual std::string GetErrorMessage(int error_code) = 0;
};

struct IMmAccess
{
  virtual ~IMmAccess() = default;

  virtual uint32_t ReadRegister(uint32_t address) = 0;

  virtual void WriteRegister(uint32_t address, uint32_t value) = 0;

  virtual void ReadContiguous(uint32_t address, uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  void ReadContiguous(uint32_t address, uint8_t(&buffer)[N])
  {
    return ReadContiguous(address, buffer, N);
  }

  template<std::size_t N>
  void ReadContiguous(uint32_t address, std::array<uint8_t, N>& array)
  {
    return ReadContiguous(address, array.data(), N);
  }

  virtual void WriteContiguous(uint32_t address, const uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  void WriteContiguous(uint32_t address, const uint8_t(&buffer)[N])
  {
    return WriteContiguous(address, buffer, N);
  }

  template<std::size_t N>
  void WriteContiguous(uint32_t address, const std::array<uint8_t, N>& array)
  {
    return WriteContiguous(address, array.data(), N);
  }

  virtual void ReadMailbox(uint32_t address, uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  void ReadMailbox(uint32_t address, uint8_t(&buffer)[N])
  {
    return ReadMailbox(address, buffer, N);
  }

  template<std::size_t N>
  void ReadMailbox(uint32_t address, std::array<uint8_t, N>& array)
  {
    return ReadMailbox(address, array.data(), N);
  }

  virtual void WriteMailbox(uint32_t address, const uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  void WriteMailbox(uint32_t address, const uint8_t(&buffer)[N])
  {
    return WriteMailbox(address, buffer, N);
  }

  template<std::size_t N>
  void WriteMailbox(uint32_t address, const std::array<uint8_t, N>& array)
  {
    return WriteMailbox(address, array.data(), N);
  }

  virtual void ReadMailbox(uint32_t address, uint32_t* buffer_p, std::size_t count) = 0;

  template<std::size_t N>
  void ReadMailbox(uint32_t address, uint32_t(&buffer)[N])
  {
    return ReadMailbox(address, buffer, N);
  }

  template<std::size_t N>
  void ReadMailbox(uint32_t address, std::array<uint32_t, N>& array)
  {
    return ReadMailbox(address, array.data(), N);
  }

  virtual void WriteMailbox(uint32_t address, const uint32_t* buffer_p, std::size_t count) = 0;

  template<std::size_t N>
  void WriteMailbox(uint32_t address, const uint32_t(&buffer)[N])
  {
    return WriteMailbox(address, buffer, N);
  }

  template<std::size_t N>
  void WriteMailbox(uint32_t address, const std::array<uint32_t, N>& array)
  {
    return WriteMailbox(address, array.data(), N);
  }

};

struct IStream
{
  virtual ~IStream() = default;

  enum class TransferResult
  {
    Success,
    Failed
  };

  struct TransferDetails
  {
    uint8_t* buffer_p;
    std::size_t requested;
    std::size_t transferred;
    TransferResult result;
    uint16_t frame_number;
  };

        typedef std::function<void(const TransferDetails&)> CompletionCallback_t;

  virtual std::size_t Read(uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  std::size_t Read(uint8_t(&buffer)[N])
  {
    return Read(buffer, N);
  }

  template<std::size_t N>
  std::size_t Read(std::array<uint8_t, N>& array)
  {
    return Read(array.data(), N);
  }

  virtual std::size_t Write(const uint8_t* buffer_p, std::size_t bufSize) = 0;

  template<std::size_t N>
  std::size_t Write(const uint8_t(&buffer)[N])
  {
    return Write(buffer, N);
  }

  template<std::size_t N>
  std::size_t Write(const std::array<uint8_t, N>& array)
  {
    return Write(array.data(), N);
  }

  virtual void ReadAsync(uint8_t* buffer_p, std::size_t bufSize, CompletionCallback_t cb) = 0;

  virtual void WriteAsync(const uint8_t* buffer_p, std::size_t bufSize, CompletionCallback_t cb) = 0;

  virtual void Flush() = 0;
};

struct IFpgaManager
{
  virtual ~IFpgaManager() = default;
  
  virtual const types::ApiUrl& Url() const = 0;

  virtual config::ConfigSettings Config() const = 0;

  virtual types::ApiDetails Details() const = 0;

  virtual void Configure(const config::ConfigSettings& settings) = 0;

  virtual ISystem& SystemApi() = 0;

  virtual IMmAccess& CreateMemoryMap(unsigned stream_idx) = 0;

  virtual IStream& CreateStream(unsigned stream_idx, StreamType type, StreamDirection direction) = 0;

  virtual void Open() = 0;
};

// ================================================================================
// TRAILER
// ================================================================================

}
}