ep.hpp

#pragma once
 
#include <cstdint>
 
#include "double_buffer.hpp"
#include "libxr_cb.hpp"
#include "libxr_def.hpp"
#include "libxr_mem.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)
  {
  }
 
  virtual ~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;
 
  virtual ErrorCode Stall() = 0;
 
  virtual ErrorCode ClearStall() = 0;
 
  virtual ErrorCode Transfer(size_t size) = 0;
 
  virtual ErrorCode TransferMultiBulk(RawData& data)
  {
    auto ep_buf = GetBuffer();
    size_t max_chunk = MaxTransferSize();
 
    ASSERT(max_chunk > 0);
 
    // 单包就能搞定的情况：不进入 multi-bulk 状态机，保持原有行为
    if (data.size_ <= max_chunk)
    {
      if (GetDirection() == Direction::IN)
      {
        multi_bulk_ = false;
        multi_bulk_remain_ = 0;
        multi_bulk_data_ = {nullptr, 0};
 
        auto src = static_cast<const uint8_t*>(data.addr_);
        auto dst = static_cast<uint8_t*>(ep_buf.addr_);
        Memory::FastCopy(dst, src, data.size_);
 
        return Transfer(data.size_);
      }
 
      // OUT：接收——为了把数据回填到 data，单包也走 multi-bulk
      if (GetDirection() == Direction::OUT)
      {
        multi_bulk_ = true;
        multi_bulk_data_ = data;
        multi_bulk_remain_ = data.size_;  // OUT: 剩余可写容量
        return Transfer(data.size_);
      }
 
      return ErrorCode::ARG_ERR;
    }
 
    // 需要多包处理的情况
    multi_bulk_ = true;
    multi_bulk_data_ = data;          // 应用层 buffer 指针 + 最大容量 / 逻辑总长
    multi_bulk_remain_ = data.size_;  // IN: 剩余待发送；OUT: 剩余可写容量
 
    // 第一包大小
    size_t first = max_chunk;
    if (first > multi_bulk_remain_)
    {
      first = multi_bulk_remain_;
    }
 
    if (GetDirection() == Direction::IN)
    {
      // IN：发送时，先把第一 chunk 拷到 EP buffer
      auto src = static_cast<const uint8_t*>(multi_bulk_data_.addr_);
      auto dst = static_cast<uint8_t*>(ep_buf.addr_);
      Memory::FastCopy(dst, src, first);
 
      multi_bulk_remain_ -= first;  // 已经准备好 first 字节要发
    }
    // OUT：接收时，先启动一次接收，稍后在回调里拷贝到 multi_bulk_data_
 
    return Transfer(first);
  }
 
  virtual ErrorCode TransferZLP() { return Transfer(0); }
 
  void OnTransferCompleteCallback(bool in_isr, size_t actual_transfer_size)
  {
    if (GetState() != State::BUSY)
    {
      return;
    }
 
    bool callback_uses_app_buffer = false;
    bool out_switched_before_cb = false;
 
    const Direction DIR = GetDirection();
    const size_t MAX_CHUNK = MaxTransferSize();
    const bool DB = UseDoubleBuffer();
 
    if (multi_bulk_)
    {
      if (DIR == Direction::IN)
      {
        if (multi_bulk_remain_ > 0)
        {
          auto ep_buf = GetBuffer();  // 此时应是“下一块 Active”（因为 Transfer 已切换）
          const size_t SENT = multi_bulk_data_.size_ - multi_bulk_remain_;
 
          size_t chunk = MAX_CHUNK;
          if (chunk > multi_bulk_remain_) chunk = multi_bulk_remain_;
 
          auto src = static_cast<const uint8_t*>(multi_bulk_data_.addr_) + SENT;
          auto dst = static_cast<uint8_t*>(ep_buf.addr_);
          Memory::FastCopy(dst, src, chunk);
          multi_bulk_remain_ -= chunk;
 
          SetState(State::IDLE);
          (void)Transfer(chunk);
          return;
        }
 
        // 结束：对上层报告 app buffer
        multi_bulk_ = false;
        callback_uses_app_buffer = true;
        actual_transfer_size = multi_bulk_data_.size_;
      }
      else
      {
        // OUT：完成时 Active 里是数据
        auto ep_buf = GetBuffer();
        size_t prev_remain = multi_bulk_remain_;
        size_t recvd = actual_transfer_size;
        if (recvd > prev_remain)
        {
          recvd = prev_remain;
        }
 
        const size_t OFFSET = multi_bulk_data_.size_ - prev_remain;
 
        auto dst = static_cast<uint8_t*>(multi_bulk_data_.addr_) + OFFSET;
        auto src = static_cast<const uint8_t*>(ep_buf.addr_);
        Memory::FastCopy(dst, src, recvd);
 
        multi_bulk_remain_ = prev_remain - recvd;
 
        const bool SHORT_PACKET = (recvd < MAX_CHUNK);
        const bool BUFFER_FULL = (multi_bulk_remain_ == 0);
 
        if (DB)
        {
          SwitchBuffer();  // 切换后 Pending = 刚接收的包；Active = 下次用
          out_switched_before_cb = true;
        }
 
        if (!SHORT_PACKET && !BUFFER_FULL)
        {
          size_t chunk = MAX_CHUNK;
          if (chunk > multi_bulk_remain_)
          {
            chunk = multi_bulk_remain_;
          }
 
          SetState(State::IDLE);
          (void)Transfer(chunk);  // 下一包将落到新的 Active（
          return;
        }
 
        multi_bulk_ = false;
        callback_uses_app_buffer = true;
        actual_transfer_size = multi_bulk_data_.size_ - multi_bulk_remain_;
      }
    }
 
    // 非 multi-bulk：OUT 也必须“回调前切换”
    if (!multi_bulk_ && DB && DIR == Direction::OUT && !out_switched_before_cb)
    {
      SwitchBuffer();
      out_switched_before_cb = true;
    }
 
    SetState(State::IDLE);
 
    ConstRawData data;
    if (callback_uses_app_buffer)
    {
      data = ConstRawData(multi_bulk_data_.addr_, actual_transfer_size);
    }
    else
    {
      if (DB)
      {
        // 回调里永远取 Pending = 刚刚完成的那包（IN/OUT 一致）
        data = ConstRawData(double_buffer_.PendingBuffer(), actual_transfer_size);
      }
      else
      {
        data = ConstRawData(buffer_.addr_, actual_transfer_size);
      }
    }
 
    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_;  
 
  bool multi_bulk_ = false;  
  RawData multi_bulk_data_;  
  size_t multi_bulk_remain_ =
      0;  
};
 
}  // namespace LibXR::USB