ep.hpp

#pragma once
 
#include <cstdint>
 
#include "double_buffer.hpp"
#include "libxr_cb.hpp"
#include "libxr_def.hpp"
#include "libxr_rw.hpp"
#include "libxr_type.hpp"
 
namespace LibXR::USB
{
 
class Endpoint
{
 public:
  enum class Direction : uint8_t
  {
    OUT = 0,  
    IN = 1,   
    BOTH = 2  
  };
 
  enum class EPNumber : uint8_t
  {
    EP0 = 0,           
    EP1 = 1,           
    EP2 = 2,           
    EP3 = 3,           
    EP4 = 4,           
    EP5 = 5,           
    EP6 = 6,           
    EP7 = 7,           
    EP8 = 8,           
    EP9 = 9,           
    EP10 = 10,         
    EP11 = 11,         
    EP12 = 12,         
    EP13 = 13,         
    EP14 = 14,         
    EP15 = 15,         
    EP_MAX_NUM = 16,   
    EP_AUTO = 0xFE,    
    EP_INVALID = 0xFF  
  };
 
  enum class Type : uint8_t
  {
    CONTROL = 0,      
    ISOCHRONOUS = 1,  
    BULK = 2,         
    INTERRUPT = 3     
  };
 
  enum class State : uint8_t
  {
    DISABLED,  
    IDLE,      
    BUSY,      
    STALLED,   
    ERROR      
  };
 
  static constexpr uint8_t EPNumberToInt8(EPNumber ep)
  {
    return static_cast<uint8_t>(ep);
  }
 
  static constexpr uint8_t EPNumberToAddr(EPNumber ep, Direction dir)
  {
    ASSERT(dir == Direction::IN || dir == Direction::OUT);
    return static_cast<uint8_t>(ep) | (dir == Direction::IN ? 0x80 : 0x00);
  }
 
  static constexpr EPNumber AddrToEPNumber(uint8_t addr, Direction& dir)
  {
    dir = addr & 0x80 ? Direction::IN : Direction::OUT;
    return static_cast<EPNumber>(addr & 0x7F);
  }
 
  static constexpr EPNumber NextEPNumber(EPNumber ep)
  {
    ASSERT(ep <= EPNumber::EP15);
    return static_cast<EPNumber>(EPNumberToInt8(ep) + 1);
  }
 
  struct Config
  {
    Direction direction = Direction::OUT;   
    Type type = Type::BULK;                 
    uint16_t max_packet_size = UINT16_MAX;  
    bool double_buffer = false;
    uint8_t mult = 0;  
  };
 
  explicit Endpoint(EPNumber number, Direction dir, RawData buffer)
      : number_(number), avail_direction_(dir), buffer_(buffer), double_buffer_(buffer)
  {
  }
 
  ~Endpoint() = default;
 
  // 禁止拷贝
  Endpoint(const Endpoint&) = delete;
  Endpoint& operator=(const Endpoint&) = delete;
 
  EPNumber GetNumber() const { return number_; }
 
  Direction AvailableDirection() const { return avail_direction_; }
 
  Direction GetDirection() const
  {
    if (state_ == State::DISABLED)
    {
      return AvailableDirection();
    }
    return config_.direction;
  }
 
  uint8_t GetAddress() const
  {
    if (state_ == State::DISABLED)
    {
      return EPNumberToInt8(number_) & 0x0F;
    }
    return EPNumberToAddr(number_, config_.direction);
  }
 
  State GetState() const { return state_; }
 
  void SetState(State state) { state_ = state; }
 
  Type GetType() const { return config_.type; }
 
  uint16_t MaxPacketSize() const { return config_.max_packet_size; }
 
  bool IsStalled() const { return state_ == State::STALLED; }
 
  bool UseDoubleBuffer() const { return config_.double_buffer; }
 
  RawData GetBuffer() const
  {
    if (config_.double_buffer)
    {
      return {double_buffer_.ActiveBuffer(), double_buffer_.Size()};
    }
    else
    {
      return buffer_;
    }
  }
 
  void SetOnTransferCompleteCallback(Callback<ConstRawData&> cb)
  {
    on_transfer_complete_ = cb;
  }
 
  void SetActiveLength(uint16_t len) { double_buffer_.SetActiveLength(len); }
 
  size_t GetActiveLength() { return double_buffer_.GetActiveLength(); }
 
  virtual size_t MaxTransferSize() const { return MaxPacketSize(); }
 
  virtual void Configure(const Config& cfg) = 0;
 
  virtual void Close() = 0;
 
  ErrorCode virtual Stall() = 0;
 
  ErrorCode virtual ClearStall() = 0;
 
  virtual ErrorCode Transfer(size_t size) = 0;
 
  virtual ErrorCode TransferZLP() { return Transfer(0); }
 
  void OnTransferCompleteCallback(bool in_isr, size_t actual_transfer_size)
  {
    if (GetState() != State::BUSY)
    {
      return;
    }
 
    SetState(State::IDLE);
 
    ConstRawData data = UseDoubleBuffer()
                            ? ConstRawData(GetDirection() == Direction::OUT
                                               ? double_buffer_.ActiveBuffer()
                                               : double_buffer_.PendingBuffer(),
                                           actual_transfer_size)
                            : ConstRawData(buffer_.addr_, actual_transfer_size);
 
    if (UseDoubleBuffer() && GetDirection() == Direction::OUT)
    {
      SwitchBuffer();
    }
 
    on_transfer_complete_.Run(in_isr, data);
  }
 
 protected:
  Config& GetConfig() { return config_; }
 
  virtual void SwitchBuffer()
  {
    double_buffer_.EnablePending();
    double_buffer_.Switch();
  }
 
  virtual void SetActiveBlock(bool active_block)
  {
    double_buffer_.SetActiveBlock(active_block);
    double_buffer_.EnablePending();
  }
 
 private:
  LibXR::Callback<LibXR::ConstRawData&> on_transfer_complete_;
 
  EPNumber number_;                    
  Direction avail_direction_;          
  Config config_;                      
  State state_ = State::DISABLED;      
  LibXR::RawData buffer_;              
  LibXR::DoubleBuffer double_buffer_;  
};  // namespace LibXR::USB
 
}  // namespace LibXR::USB