spi.hpp

#pragma once
 
#include "double_buffer.hpp"
#include "libxr.hpp"
 
namespace LibXR
{
 
class SPI
{
 public:
  enum class ClockPolarity : uint8_t
  {
    LOW = 0,  
    HIGH = 1  
  };
 
  enum class ClockPhase : uint8_t
  {
    EDGE_1 = 0,  
    EDGE_2 = 1   
  };
 
  enum class Prescaler : uint8_t
  {
    DIV_1 = 0,       
    DIV_2 = 1,       
    DIV_4 = 2,       
    DIV_8 = 3,       
    DIV_16 = 4,      
    DIV_32 = 5,      
    DIV_64 = 6,      
    DIV_128 = 7,     
    DIV_256 = 8,     
    DIV_512 = 9,     
    DIV_1024 = 10,   
    DIV_2048 = 11,   
    DIV_4096 = 12,   
    DIV_8192 = 13,   
    DIV_16384 = 14,  
    DIV_32768 = 15,  
    DIV_65536 = 16,  
    UNKNOWN = 0xFF   
  };
 
  using OperationRW = WriteOperation;
 
  static constexpr uint32_t PrescalerToDiv(Prescaler prescaler)
  {
    if (prescaler == Prescaler::UNKNOWN)
    {
      return 0u;
    }
    const uint8_t ORD = static_cast<uint8_t>(prescaler);
    return (ORD <= 30) ? (1u << ORD) : 0u;
  }
 
  struct Configuration
  {
    ClockPolarity clock_polarity =
        ClockPolarity::LOW;                       
    ClockPhase clock_phase = ClockPhase::EDGE_1;  
    Prescaler prescaler = Prescaler::UNKNOWN;     
    bool double_buffer = false;  
  };
 
  struct ReadWriteInfo
  {
    RawData read_data;        
    ConstRawData write_data;  
    OperationRW op;           
  };
 
  SPI(RawData rx_buffer, RawData tx_buffer)
      : rx_buffer_(rx_buffer),
        tx_buffer_(tx_buffer),
        double_buffer_rx_(rx_buffer),
        double_buffer_tx_(tx_buffer)
  {
  }
 
  virtual ErrorCode ReadAndWrite(RawData read_data, ConstRawData write_data,
                                 OperationRW &op) = 0;
 
  virtual ErrorCode Read(RawData read_data, OperationRW &op)
  {
    return ReadAndWrite(read_data, ConstRawData(nullptr, 0), op);
  }
 
  virtual ErrorCode Write(ConstRawData write_data, OperationRW &op)
  {
    return ReadAndWrite(RawData(nullptr, 0), write_data, op);
  }
 
  virtual ErrorCode SetConfig(Configuration config) = 0;
 
  virtual uint32_t GetMaxBusSpeed() const = 0;
 
  virtual Prescaler GetMaxPrescaler() const = 0;
 
  uint32_t GetBusSpeed() const
  {
    const uint32_t DIV = PrescalerToDiv(config_.prescaler);
    const uint32_t SRC = GetMaxBusSpeed();
    if (DIV == 0u || SRC == 0u)
    {
      return 0u;
    }
    return SRC / DIV;
  }
 
  Prescaler CalcPrescaler(uint32_t target_max_bus_speed, uint32_t target_min_bus_speed,
                          bool increase)
  {
    const uint32_t SRC = GetMaxBusSpeed();
    if (SRC == 0u)
    {
      return Prescaler::UNKNOWN;
    }
 
    if (target_max_bus_speed && target_min_bus_speed &&
        target_min_bus_speed > target_max_bus_speed)
    {
      uint32_t t = target_min_bus_speed;
      target_min_bus_speed = target_max_bus_speed;
      target_max_bus_speed = t;
    }
 
    const uint8_t MAX_IDX = static_cast<uint8_t>(GetMaxPrescaler());
 
    ASSERT(MAX_IDX != static_cast<uint8_t>(Prescaler::UNKNOWN));
 
    auto fits = [&](Prescaler p) -> bool
    {
      const uint32_t DIV = PrescalerToDiv(p);
      if (DIV == 0u)
      {
        return false;
      }
      const uint32_t F = SRC / DIV;
      if (target_max_bus_speed && F > target_max_bus_speed)
      {
        return false;
      }
      if (target_min_bus_speed && F < target_min_bus_speed)
      {
        return false;
      }
      return true;
    };
 
    if (increase)
    {
      for (uint8_t i = 0; i <= MAX_IDX; ++i)
      {
        Prescaler p = static_cast<Prescaler>(i);
        if (fits(p))
        {
          return p;
        }
      }
    }
    else
    {
      for (int i = static_cast<int>(MAX_IDX); i >= 0; --i)
      {
        Prescaler p = static_cast<Prescaler>(i);
        if (fits(p))
        {
          return p;
        }
      }
    }
 
    const uint32_t F_FASTEST = SRC / PrescalerToDiv(Prescaler::DIV_1);
    const Prescaler P_SLOWEST = static_cast<Prescaler>(MAX_IDX);
    const uint32_t F_SLOWEST = SRC / PrescalerToDiv(P_SLOWEST);
 
    if (target_min_bus_speed && F_FASTEST < target_min_bus_speed)
    {
      return Prescaler::DIV_1;
    }
    if (target_max_bus_speed && F_SLOWEST > target_max_bus_speed)
    {
      return P_SLOWEST;
    }
 
    if (increase)
    {
      for (uint8_t i = 0; i <= MAX_IDX; ++i)
      {
        Prescaler p = static_cast<Prescaler>(i);
        const uint32_t F = SRC / PrescalerToDiv(p);
        if (!target_max_bus_speed || F <= target_max_bus_speed)
        {
          return p;
        }
      }
      return P_SLOWEST;
    }
    else
    {
      for (int i = static_cast<int>(MAX_IDX); i >= 0; --i)
      {
        Prescaler p = static_cast<Prescaler>(i);
        const uint32_t F = SRC / PrescalerToDiv(p);
        if (!target_min_bus_speed || F >= target_min_bus_speed)
        {
          return p;
        }
      }
      return Prescaler::DIV_1;
    }
  }
 
  RawData GetRxBuffer()
  {
    if (IsDoubleBuffer())
    {
      return {double_buffer_rx_.ActiveBuffer(), double_buffer_rx_.Size()};
    }
    else
    {
      return rx_buffer_;
    }
  }
 
  RawData GetTxBuffer()
  {
    if (IsDoubleBuffer())
    {
      return {double_buffer_tx_.ActiveBuffer(), double_buffer_tx_.Size()};
    }
    else
    {
      return tx_buffer_;
    }
  }
 
  void SwitchBuffer()
  {
    if (IsDoubleBuffer())
    {
      double_buffer_rx_.Switch();
      double_buffer_tx_.Switch();
    }
  }
 
  void SetActiveLength(size_t len) { double_buffer_tx_.SetActiveLength(len); }
 
  size_t GetActiveLength() const { return double_buffer_tx_.GetActiveLength(); }
 
  virtual ErrorCode Transfer(size_t size, OperationRW &op) = 0;
 
  virtual ErrorCode MemWrite(uint16_t reg, ConstRawData write_data, OperationRW &op) = 0;
 
  virtual ErrorCode MemRead(uint16_t reg, RawData read_data, OperationRW &op) = 0;
 
  inline Configuration &GetConfig() { return config_; }
 
  inline bool IsDoubleBuffer() const { return config_.double_buffer; }
 
 private:
  Configuration config_;
  RawData rx_buffer_, tx_buffer_;
  DoubleBuffer double_buffer_rx_, double_buffer_tx_;
};
 
}  // namespace LibXR