cdc_uart.hpp

#pragma once
 
#include "cdc_base.hpp"
#include "ep.hpp"
#include "libxr_def.hpp"
#include "libxr_rw.hpp"
#include "serialized_service.hpp"
 
namespace LibXR::USB
{
 
class CDCUart;
 
class CDCUartReadPort : public ReadPort
{
 public:
  explicit CDCUartReadPort(uint32_t size, CDCUart& owner) : ReadPort(size), owner_(owner)
  {
  }
 
 protected:
  void OnReadQueueSpaceAvailable(bool in_isr) override;
 
 public:
  CDCUart& owner_;           
  bool recv_pause_ = false;  
  ConstRawData pending_data_{nullptr,
                             0};  
};
 
class CDCUart : public CDCBase, public LibXR::UART
{
 public:
  using LibXR::UART::Read;
  using LibXR::UART::read_port_;
  using LibXR::UART::Write;
  using LibXR::UART::write_port_;
 
  CDCUart(
      Endpoint::EPNumber data_in_ep_num, Endpoint::EPNumber data_out_ep_num,
      Endpoint::EPNumber comm_ep_num, size_t rx_buffer_size = 128,
      size_t tx_buffer_size = 128, size_t tx_queue_size = 5,
      const char* control_interface_string = CDCBase::DEFAULT_CONTROL_INTERFACE_STRING,
      const char* data_interface_string = CDCBase::DEFAULT_DATA_INTERFACE_STRING)
      : CDCBase(data_in_ep_num, data_out_ep_num, comm_ep_num, control_interface_string,
                data_interface_string),
        LibXR::UART(&read_port_cdc_, &write_port_cdc_),
        read_port_cdc_(rx_buffer_size, *this),
        write_port_cdc_(tx_queue_size, tx_buffer_size)
  {
    write_port_cdc_ = WriteFun;  // NOLINT
  }
 
  ErrorCode SetConfig(UART::Configuration cfg, bool in_isr = false) override
  {
    UNUSED(in_isr);
    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:
      case 6:
      case 7:
      case 8:
      case 16:
        line_coding.bDataBits = static_cast<uint8_t>(cfg.data_bits);
        break;
      default:
        return ErrorCode::ARG_ERR;
    }
 
    line_coding.dwDTERate = cfg.baudrate;
    SendSerialState();
    return ErrorCode::OK;
  }
 
  bool TryRearmOut(bool in_isr)
  {
    auto* ep = GetDataOutEndpoint();
    if (ep == nullptr || ep->MaxPacketSize() == 0U || !read_port_cdc_.Readable())
    {
      return false;
    }
 
    if (read_port_cdc_.recv_pause_ && read_port_cdc_.pending_data_.size_ != 0U)
    {
      auto queue = read_port_cdc_.GetReadQueue(in_isr);
      if (queue.EmptySize() < read_port_cdc_.pending_data_.size_)
      {
        queue.Publish();
        return false;
      }
 
      [[maybe_unused]] const auto ans =
          queue.PushBatch(static_cast<const uint8_t*>(read_port_cdc_.pending_data_.addr_),
                          read_port_cdc_.pending_data_.size_);
      DEV_ASSERT_FROM_CALLBACK(ans == ErrorCode::OK, in_isr);
      read_port_cdc_.pending_data_ = {nullptr, 0};
      queue.Publish();
    }
 
    if (ep->GetState() != Endpoint::State::IDLE)
    {
      return false;
    }
 
    [[maybe_unused]] const auto ans = ep->Transfer(ep->MaxPacketSize());
    if (ans == ErrorCode::OK)
    {
      read_port_cdc_.recv_pause_ = false;
      return true;
    }
    return false;
  }
 
 protected:
  void BindEndpoints(EndpointPool& endpoint_pool, uint8_t start_itf_num,
                     bool in_isr) override;
 
  void UnbindEndpoints(EndpointPool& endpoint_pool, bool in_isr) override
  {
    CDCBase::UnbindEndpoints(endpoint_pool, in_isr);
    need_write_zlp_ = false;
    read_port_cdc_.recv_pause_ = false;
    read_port_cdc_.pending_data_ = {nullptr, 0};
  }
 
  static void WriteFun(WritePort& port, bool in_isr);
 
  void OnDataOutComplete(bool in_isr, ConstRawData& data) override
  {
    if (data.size_ != 0U)
    {
      auto queue = read_port_cdc_.GetReadQueue(in_isr);
      if (queue.EmptySize() < data.size_)
      {
        read_port_cdc_.recv_pause_ = true;
        read_port_cdc_.pending_data_ = data;
        queue.Publish();
        return;
      }
 
      [[maybe_unused]] const auto ans =
          queue.PushBatch(static_cast<const uint8_t*>(data.addr_), data.size_);
      DEV_ASSERT_FROM_CALLBACK(ans == ErrorCode::OK, in_isr);
      queue.Publish();
    }
    (void)TryRearmOut(in_isr);
  }
 
  void OnDataInComplete(bool in_isr, ConstRawData& data) override;
 
 private:
  void RequestTx(bool in_isr);
 
  void ServiceTx(bool in_isr);
 
  void StartTxBuffer(Endpoint& ep, [[maybe_unused]] bool in_isr);
 
  void FillTxBuffer(Endpoint& ep, bool in_isr);
 
  void ProgressTx(bool in_isr);
 
  CDCUartReadPort read_port_cdc_;    
  LibXR::WritePort write_port_cdc_;  
  SerializedService tx_service_;     
  bool need_write_zlp_ = false;      
};
 
inline void CDCUartReadPort::OnReadQueueSpaceAvailable(bool in_isr)
{
  if (recv_pause_)
  {
    (void)owner_.TryRearmOut(in_isr);
  }
}
 
}  // namespace LibXR::USB