cdc_uart.hpp

#pragma once
#include <cstring>
 
#include "cdc_base.hpp"
 
namespace LibXR::USB
{
 
class CDCUart : public CDCBase, public LibXR::UART
{
 public:
  // 公开 UART API 及底层端口对象（如需隐藏端口对象，可移除 read_port_/write_port_ 的
  // using）
  using LibXR::UART::Read;
  using LibXR::UART::read_port_;
  using LibXR::UART::Write;
  using LibXR::UART::write_port_;
 
  CDCUart(size_t rx_buffer_size = 128, size_t tx_buffer_size = 128,
          size_t tx_queue_size = 5,
          Endpoint::EPNumber data_in_ep_num = Endpoint::EPNumber::EP_AUTO,
          Endpoint::EPNumber data_out_ep_num = Endpoint::EPNumber::EP_AUTO,
          Endpoint::EPNumber comm_ep_num = Endpoint::EPNumber::EP_AUTO)
      : CDCBase(data_in_ep_num, data_out_ep_num, comm_ep_num),
        LibXR::UART(&read_port_cdc_, &write_port_cdc_),
        read_port_cdc_(rx_buffer_size),
        write_port_cdc_(tx_queue_size, tx_buffer_size)
  {
    // 初始化端口读写函数
    read_port_cdc_ = ReadFun;    // NOLINT
    write_port_cdc_ = WriteFun;  // NOLINT
  }
 
  ErrorCode SetConfig(UART::Configuration cfg) override
  {
    auto& line_coding = GetLineCoding();
 
    // 设置停止位
    switch (cfg.stop_bits)
    {
      case 1:
        line_coding.bCharFormat = 0;
        break;
      case 2:
        line_coding.bCharFormat = 2;
        break;
      default:
        return ErrorCode::ARG_ERR;
    }
 
    // 设置校验位
    switch (cfg.parity)
    {
      case UART::Parity::NO_PARITY:
        line_coding.bParityType = 0;
        break;
      case UART::Parity::ODD:
        line_coding.bParityType = 1;
        break;
      case UART::Parity::EVEN:
        line_coding.bParityType = 2;
        break;
      default:
        return ErrorCode::ARG_ERR;
    }
 
    // 设置数据位
    switch (cfg.data_bits)
    {
      case 5:
        line_coding.bDataBits = 5;
        break;
      case 6:
        line_coding.bDataBits = 6;
        break;
      case 7:
        line_coding.bDataBits = 7;
        break;
      case 8:
        line_coding.bDataBits = 8;
        break;
      case 16:
        line_coding.bDataBits = 16;
        break;
      default:
        return ErrorCode::ARG_ERR;
    }
 
    // 设置波特率
    line_coding.dwDTERate = cfg.baudrate;
 
    SendSerialState();
 
    return ErrorCode::OK;
  }
 
 protected:
  void Deinit(EndpointPool& endpoint_pool) override
  {
    CDCBase::Deinit(endpoint_pool);
    LibXR::WriteInfoBlock info;
    while (write_port_cdc_.queue_info_->Pop(info) == ErrorCode::OK)
    {
      write_port_cdc_.queue_data_->PopBatch(nullptr, info.data.size_);
      write_port_cdc_.Finish(true, ErrorCode::INIT_ERR, info, 0);
    }
    write_port_cdc_.Reset();
  }
 
  static ErrorCode WriteFun(WritePort& port)
  {
    CDCUart* cdc = CONTAINER_OF(&port, CDCUart, write_port_cdc_);
 
    auto ep_data_in = cdc->GetDataInEndpoint();
 
    // 检查是否已初始化且DTR已设置
    if (!cdc->Inited() || !cdc->IsDtrSet())
    {
      if (ep_data_in->GetActiveLength() == 0)
      {
        WriteInfoBlock info;
        auto ans = port.queue_info_->Pop(info);
        if (ans != ErrorCode::OK)
        {
          return ErrorCode::EMPTY;
        }
        port.queue_data_->PopBatch(nullptr, info.data.size_);
        port.Finish(true, ErrorCode::INIT_ERR, info, 0);
      }
      return ErrorCode::FAILED;
    }
 
    size_t dequeued = 0;
 
    while (port.queue_info_->Size() > 0)
    {
      // 检查当前是否有传输正在进行
      if (ep_data_in->GetActiveLength() > 0 || cdc->need_write_zlp_)
      {
        return ErrorCode::FAILED;
      }
 
      auto buffer = ep_data_in->GetBuffer();
 
      WriteInfoBlock info;
 
      // 获取队列中的写操作信息
      if (port.queue_info_->Peek(info) != ErrorCode::OK)
      {
        return ErrorCode::EMPTY;
      }
 
      size_t need_write = info.data.size_ - dequeued;
 
      if (need_write == 0)
      {
        return ErrorCode::OK;
      }
 
      // 检查数据大小是否超出缓冲区
      if (need_write > buffer.size_)
      {
        need_write = buffer.size_;
      }
 
      // 从队列获取数据
      if (port.queue_data_->PopBatch(reinterpret_cast<uint8_t*>(buffer.addr_),
                                     need_write) != ErrorCode::OK)
      {
        ASSERT(false);
        return ErrorCode::EMPTY;
      }
 
      dequeued += need_write;
 
      cdc->written_ += need_write;
 
      if (cdc->written_ >= info.data.size_)
      {
        port.queue_info_->Pop();
        port.Finish(false, ErrorCode::OK, info, info.data.size_);
        cdc->written_ -= info.data.size_;
      }
 
      ep_data_in->SetActiveLength(need_write);
 
      // 保证对 ActiveLength/缓冲区的可见性顺序（与 ISR/USB 控制器交互）
      // Ensure visibility/order for ActiveLength/buffer updates across ISR/USB controller
      std::atomic_signal_fence(std::memory_order_seq_cst);
 
      // 如果端点空闲且有数据待发送
      if (ep_data_in->GetState() == Endpoint::State::IDLE &&
          ep_data_in->GetActiveLength() != 0)
      {
        /* 可以立即发送 */
      }
      else
      {
        return ErrorCode::FAILED;
      }
 
      // 启动传输
      auto ans = ErrorCode::OK;
 
      ep_data_in->SetActiveLength(0);
 
      ans = ep_data_in->Transfer(need_write);
 
      ASSERT(ans == ErrorCode::OK);
    }
 
    return ErrorCode::OK;
  }
 
  static ErrorCode ReadFun(ReadPort& port)
  {
    UNUSED(port);
    return ErrorCode::EMPTY;
  }
 
  void OnDataOutComplete(bool in_isr, ConstRawData& data) override
  {
    // 重启OUT端点传输
    auto ep_data_out = GetDataOutEndpoint();
    ep_data_out->Transfer(ep_data_out->MaxTransferSize());
 
    if (data.size_ > 0)
    {
      // 将接收到的数据推入接收缓冲区
      read_port_cdc_.queue_data_->PushBatch(reinterpret_cast<const uint8_t*>(data.addr_),
                                            data.size_);
      // 处理待处理的读取操作
      read_port_cdc_.ProcessPendingReads(in_isr);
    }
  }
 
  void OnDataInComplete(bool in_isr, ConstRawData& data) override
  {
    UNUSED(in_isr);
    UNUSED(data);
 
    auto ep_data_in = GetDataInEndpoint();
 
    size_t pending_len = ep_data_in->GetActiveLength();
 
    if (pending_len == 0)
    {
      // TODO: zlp check
      return;
    }
 
    ep_data_in->SetActiveLength(0);
    auto ans = ep_data_in->Transfer(pending_len);
    ASSERT(ans == ErrorCode::OK);
 
    LibXR::WriteInfoBlock info;
 
    if (write_port_cdc_.queue_info_->Peek(info) != ErrorCode::OK)
    {
      return;
    }
 
    if (!Inited() || !IsDtrSet())
    {
      write_port_cdc_.queue_data_->PopBatch(nullptr, info.data.size_);
      write_port_cdc_.Finish(true, ErrorCode::INIT_ERR, info, 0);
      return;
    }
 
    auto need_write = info.data.size_ - written_;
 
    if (need_write > 0)
    {
      auto buffer = ep_data_in->GetBuffer();
      if (buffer.size_ < need_write)
      {
        need_write = buffer.size_;
      }
 
      write_port_cdc_.queue_data_->PopBatch(reinterpret_cast<uint8_t*>(buffer.addr_),
                                            need_write);
      ep_data_in->SetActiveLength(need_write);
      written_ += need_write;
 
      if (written_ >= info.data.size_)
      {
        write_port_cdc_.queue_info_->Pop(info);
        write_port_cdc_.Finish(true, ErrorCode::OK, info, info.data.size_);
        written_ -= info.data.size_;
        ASSERT(written_ == 0);
      }
    }
  }
 
 private:
  // 端口对象
  LibXR::ReadPort read_port_cdc_;    
  LibXR::WritePort write_port_cdc_;  
 
  // 状态标志
  bool need_write_zlp_ = false;  
  size_t written_ = 0;           
};
 
}  // namespace LibXR::USB