cdc_base.hpp

#pragma once
#include <cstring>
 
#include "dev_core.hpp"
#include "libxr_def.hpp"
#include "uart.hpp"
#include "usb/core/desc_cfg.hpp"
 
namespace LibXR::USB
{
 
class CDCBase : public DeviceClass
{
  enum class DescriptorSubtype : uint8_t
  {
    HEADER = 0x00,  
    CALL_MANAGEMENT =
        0x01,      
    ACM = 0x02,    
    UNION = 0x06,  
  };
 
  enum class Class : uint8_t
  {
    COMM = 0x02,  
    DATA = 0x0A   
  };
 
  enum class Protocol : uint8_t
  {
    NONE = 0x00,        
    AT_COMMAND = 0x01,  
  };
 
  enum class Subclass : uint8_t
  {
    NONE = 0x00,  
    DIRECT_LINE_CONTROL_MODEL =
        0x01,  
    ABSTRACT_CONTROL_MODEL =
        0x02,  
  };
 
  enum class ClassRequest : uint8_t
  {
    SET_LINE_CODING = 0x20,         
    GET_LINE_CODING = 0x21,         
    SET_CONTROL_LINE_STATE = 0x22,  
    SEND_BREAK = 0x23               
  };
 
  enum class CDCNotification : uint8_t
  {
    NETWORK_CONNECTION = 0x00,   
    RESPONSE_AVAILABLE = 0x01,   
    AUX_JACK_HOOK_STATE = 0x08,  
    RING_DETECT = 0x09,          
    SERIAL_STATE = 0x20,  
  };
 
#pragma pack(push, 1)
  struct CDCLineCoding
  {
    uint32_t dwDTERate;   
    uint8_t bCharFormat;  
    uint8_t bParityType;  
    uint8_t bDataBits;    
  };
 
  struct SerialStateNotification
  {
    uint8_t bmRequestType;  
    uint8_t bNotification;  
    uint16_t wValue;        
    uint16_t wIndex;        
    uint16_t wLength;       
    uint16_t serialState;   
  };
#pragma pack(pop)
 
  // 确保CDCLineCoding结构体大小为7字节
  static_assert(sizeof(CDCLineCoding) == 7, "LineCoding结构必须7字节");
 
  // 控制线路状态位定义
  static constexpr uint16_t CDC_CONTROL_LINE_DTR = 0x01;  
  static constexpr uint16_t CDC_CONTROL_LINE_RTS = 0x02;  
 
 public:
  CDCBase(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)
      : data_in_ep_num_(data_in_ep_num),
        data_out_ep_num_(data_out_ep_num),
        comm_ep_num_(comm_ep_num)
  {
  }
 
  bool IsDtrSet() const { return (control_line_state_ & CDC_CONTROL_LINE_DTR) != 0; }
 
  bool IsRtsSet() const { return (control_line_state_ & CDC_CONTROL_LINE_RTS) != 0; }
 
  ErrorCode SendSerialState()
  {
    if (ep_comm_in_->GetState() == Endpoint::State::BUSY)
    {
      return ErrorCode::BUSY;
    }
    auto buffer = ep_comm_in_->GetBuffer();
    ASSERT(buffer.size_ >= sizeof(SerialStateNotification));
    SerialStateNotification* notification =
        reinterpret_cast<SerialStateNotification*>(buffer.addr_);
    notification->wIndex = itf_comm_in_num_;
 
    // 设置串行状态位
    if (IsDtrSet())
    {
      // DTR有效时报告载波检测(DCD)和数据集就绪(DSR)
      notification->serialState = 0x03;  // DCD / DSR
    }
    else
    {
      notification->serialState = 0x00;  // 无状态
    }
 
    // 填充固定字段
    notification->bmRequestType = 0xA1;  // 设备到主机，类，接口
    notification->bNotification = static_cast<uint8_t>(CDCNotification::SERIAL_STATE);
    notification->wValue = 0;
    notification->wLength = 2;
 
    ep_comm_in_->Transfer(sizeof(SerialStateNotification));
 
    return ErrorCode::OK;
  }
 
  void SetOnSetControlLineStateCallback(LibXR::Callback<bool, bool> cb)
  {
    on_set_control_line_state_cb_ = cb;
  }
 
  void SetOnSetLineCodingCallback(LibXR::Callback<LibXR::UART::Configuration> cb)
  {
    on_set_line_coding_cb_ = cb;
  }
 
 protected:
  virtual void Init(EndpointPool& endpoint_pool, uint8_t start_itf_num) override
  {
    control_line_state_ = 0;
    // 获取并配置数据IN端点
    auto ans = endpoint_pool.Get(ep_data_in_, Endpoint::Direction::IN, data_in_ep_num_);
    ASSERT(ans == ErrorCode::OK);
 
    // 获取并配置数据OUT端点
    ans = endpoint_pool.Get(ep_data_out_, Endpoint::Direction::OUT, data_out_ep_num_);
    ASSERT(ans == ErrorCode::OK);
 
    // 获取并配置通信端点
    ans = endpoint_pool.Get(ep_comm_in_, Endpoint::Direction::IN, comm_ep_num_);
    ASSERT(ans == ErrorCode::OK);
 
    // 配置端点参数
    ep_data_in_->Configure(
        {Endpoint::Direction::IN, Endpoint::Type::BULK, UINT16_MAX, true});
    ep_data_out_->Configure(
        {Endpoint::Direction::OUT, Endpoint::Type::BULK, UINT16_MAX, true});
    ep_comm_in_->Configure({Endpoint::Direction::IN, Endpoint::Type::INTERRUPT, 16});
 
    // === 填充CDC描述符块 ===
    static constexpr uint8_t COMM_INTERFACE = 0;  // 通信接口号
    static constexpr uint8_t DATA_INTERFACE = 1;  // 数据接口号
 
    // IAD描述符（关联接口）
    desc_block_.iad = {8,
                       static_cast<uint8_t>(DescriptorType::IAD),
                       static_cast<uint8_t>(COMM_INTERFACE + start_itf_num),
                       2,
                       static_cast<uint8_t>(Class::COMM),
                       static_cast<uint8_t>(Subclass::ABSTRACT_CONTROL_MODEL),
                       static_cast<uint8_t>(Protocol::NONE),
                       0};
 
    // 通信接口描述符
    desc_block_.comm_intf = {9,
                             static_cast<uint8_t>(DescriptorType::INTERFACE),
                             static_cast<uint8_t>(COMM_INTERFACE + start_itf_num),
                             0,
                             1,
                             static_cast<uint8_t>(Class::COMM),
                             static_cast<uint8_t>(Subclass::ABSTRACT_CONTROL_MODEL),
                             static_cast<uint8_t>(Protocol::NONE),
                             0};
 
    // CDC头功能描述符
    desc_block_.cdc_header = {5, DescriptorType::CS_INTERFACE, DescriptorSubtype::HEADER,
                              0x0110};  // CDC规范版本1.10
 
    // 呼叫管理功能描述符
    desc_block_.cdc_callmgmt = {
        5, DescriptorType::CS_INTERFACE, DescriptorSubtype::CALL_MANAGEMENT,
        0x00,                                                   // 无呼叫管理能力
        static_cast<uint8_t>(DATA_INTERFACE + start_itf_num)};  // 数据接口号
 
    // ACM功能描述符
    desc_block_.cdc_acm = {4, DescriptorType::CS_INTERFACE, DescriptorSubtype::ACM,
                           0x02};  // 支持SetLineCoding/GetLineCoding/SetControlLineState
 
    // 联合功能描述符
    desc_block_.cdc_union = {5, DescriptorType::CS_INTERFACE, DescriptorSubtype::UNION,
                             static_cast<uint8_t>(COMM_INTERFACE + start_itf_num),
                             static_cast<uint8_t>(DATA_INTERFACE + start_itf_num)};
 
    // 数据接口描述符
    desc_block_.data_intf = {9,
                             static_cast<uint8_t>(DescriptorType::INTERFACE),
                             static_cast<uint8_t>(DATA_INTERFACE + start_itf_num),
                             0,
                             2,
                             static_cast<uint8_t>(Class::DATA),
                             0x00,  // 无子类
                             0x00,  // 无协议
                             0};
 
    // 数据OUT端点描述符
    desc_block_.data_ep_out = {7,
                               static_cast<uint8_t>(DescriptorType::ENDPOINT),
                               ep_data_out_->GetAddress(),
                               static_cast<uint8_t>(Endpoint::Type::BULK),
                               ep_data_out_->MaxPacketSize(),
                               0};  // 轮询间隔0（BULK忽略）
 
    // 数据IN端点描述符
    desc_block_.data_ep_in = {7,
                              static_cast<uint8_t>(DescriptorType::ENDPOINT),
                              static_cast<uint8_t>(ep_data_in_->GetAddress()),
                              static_cast<uint8_t>(Endpoint::Type::BULK),
                              ep_data_in_->MaxPacketSize(),
                              0};  // 轮询间隔0（BULK忽略）
 
    // 通信端点描述符
    desc_block_.comm_ep = {
        7,
        static_cast<uint8_t>(DescriptorType::ENDPOINT),
        static_cast<uint8_t>(ep_comm_in_->GetAddress()),  // IN端点地址
        static_cast<uint8_t>(Endpoint::Type::INTERRUPT),
        16,   // 16字节最大包大小
        0x04  // 轮询间隔FS-4ms HS-1ms
    };
 
    itf_comm_in_num_ = start_itf_num;
 
    // 设置描述符原始数据
    SetData(RawData{reinterpret_cast<uint8_t*>(&desc_block_), sizeof(desc_block_)});
 
    // 设置端点传输完成回调
    ep_data_out_->SetOnTransferCompleteCallback(on_data_out_complete_cb_);
    ep_data_in_->SetOnTransferCompleteCallback(on_data_in_complete_cb_);
 
    inited_ = true;
 
    // 启动OUT端点传输
    ep_data_out_->Transfer(ep_data_out_->MaxTransferSize());
  }
 
  virtual void Deinit(EndpointPool& endpoint_pool) override
  {
    inited_ = false;
    control_line_state_ = 0;
    ep_data_in_->Close();
    ep_data_out_->Close();
    ep_comm_in_->Close();
    ep_data_in_->SetActiveLength(0);
    ep_data_out_->SetActiveLength(0);
    ep_comm_in_->SetActiveLength(0);
    endpoint_pool.Release(ep_data_in_);
    endpoint_pool.Release(ep_data_out_);
    endpoint_pool.Release(ep_comm_in_);
    ep_data_in_ = nullptr;
    ep_data_out_ = nullptr;
    ep_comm_in_ = nullptr;
  }
 
  static void OnDataOutCompleteStatic(bool in_isr, CDCBase* self, ConstRawData& data)
  {
    if (!self->inited_)
    {
      return;
    }
    self->OnDataOutComplete(in_isr, data);
  }
 
  static void OnDataInCompleteStatic(bool in_isr, CDCBase* self, ConstRawData& data)
  {
    if (!self->inited_)
    {
      return;
    }
    self->OnDataInComplete(in_isr, data);
  }
 
  virtual void OnDataOutComplete(bool in_isr, ConstRawData& data) = 0;
 
  virtual void OnDataInComplete(bool in_isr, ConstRawData& data) = 0;
 
  size_t GetInterfaceNum() override { return 2; }
 
  bool HasIAD() override { return true; }
 
  bool OwnsEndpoint(uint8_t ep_addr) const override
  {
    if (!inited_)
    {
      return false;
    }
 
    return ep_data_in_->GetAddress() == ep_addr ||
           ep_data_out_->GetAddress() == ep_addr || ep_comm_in_->GetAddress() == ep_addr;
  }
 
  size_t GetMaxConfigSize() override { return sizeof(desc_block_); }
 
  ErrorCode OnClassRequest(bool in_isr, uint8_t bRequest, uint16_t wValue,
                           uint16_t wLength, uint16_t wIndex,
                           DeviceClass::RequestResult& result) override
  {
    UNUSED(in_isr);
    UNUSED(wIndex);
 
    switch (static_cast<ClassRequest>(bRequest))
    {
      case ClassRequest::SET_LINE_CODING:
        // 主机将在数据阶段发送7字节参数
        if (wLength != sizeof(line_coding_))
        {
          return ErrorCode::ARG_ERR;
        }
        result.read_data =
            RawData{reinterpret_cast<uint8_t*>(&line_coding_), sizeof(line_coding_)};
        return ErrorCode::OK;
 
      case ClassRequest::GET_LINE_CODING:
        // 返回当前线路编码设置
        if (wLength != sizeof(line_coding_))
        {
          return ErrorCode::ARG_ERR;
        }
 
        result.write_data = ConstRawData{reinterpret_cast<const uint8_t*>(&line_coding_),
                                         sizeof(line_coding_)};
        return ErrorCode::OK;
 
      case ClassRequest::SET_CONTROL_LINE_STATE:
        // 设置DTR/RTS状态
        control_line_state_ = wValue;
        result.write_zlp = true;
        SendSerialState();
        on_set_control_line_state_cb_.Run(in_isr, IsDtrSet(), IsRtsSet());
        return ErrorCode::OK;
 
      case ClassRequest::SEND_BREAK:
        // BREAK信号通常忽略
        return ErrorCode::OK;
 
      default:
        return ErrorCode::NOT_SUPPORT;
    }
  }
 
  ErrorCode OnClassData(bool in_isr, uint8_t bRequest, LibXR::ConstRawData& data) override
  {
    UNUSED(in_isr);
    UNUSED(data);
 
    switch (static_cast<ClassRequest>(bRequest))
    {
      case ClassRequest::SET_LINE_CODING:
      {
        // 将CDC线路编码转换为UART配置
        LibXR::UART::Configuration cfg;
        cfg.baudrate = line_coding_.dwDTERate;
        switch (line_coding_.bCharFormat)
        {
          case 0:
            cfg.stop_bits = 1;
            break;
          // TODO: 1.5
          case 2:
            cfg.stop_bits = 2;
            break;
          default:
            cfg.stop_bits = 1;
        }
        switch (line_coding_.bParityType)
        {
          case 1:
            cfg.parity = LibXR::UART::Parity::ODD;
            break;
          case 2:
            cfg.parity = LibXR::UART::Parity::EVEN;
            break;
          default:
            cfg.parity = LibXR::UART::Parity::NO_PARITY;
        }
        cfg.data_bits = line_coding_.bDataBits;
        on_set_line_coding_cb_.Run(in_isr, cfg);
      }
        return ErrorCode::OK;
      default:
        return ErrorCode::NOT_SUPPORT;
    }
  }
 
#pragma pack(push, 1)
  struct CDCDescBlock
  {
    IADDescriptor iad;  
    InterfaceDescriptor
        comm_intf;  
 
    // CDC类特定描述符
    struct
    {
      uint8_t bFunctionLength = 5;
      DescriptorType bDescriptorType = DescriptorType::CS_INTERFACE;
      DescriptorSubtype bDescriptorSubtype = DescriptorSubtype::HEADER;
      uint16_t bcdCDC = 0x0110;  
    } cdc_header;
 
    struct
    {
      uint8_t bFunctionLength = 5;
      DescriptorType bDescriptorType = DescriptorType::CS_INTERFACE;
      DescriptorSubtype bDescriptorSubtype = DescriptorSubtype::CALL_MANAGEMENT;
      uint8_t bmCapabilities = 0x00;  
      uint8_t bDataInterface;         
    } cdc_callmgmt;
 
    struct
    {
      uint8_t bFunctionLength = 4;
      DescriptorType bDescriptorType = DescriptorType::CS_INTERFACE;
      DescriptorSubtype bDescriptorSubtype = DescriptorSubtype::ACM;
      uint8_t bmCapabilities = 0x02;  
    } cdc_acm;
 
    struct
    {
      uint8_t bFunctionLength = 5;
      DescriptorType bDescriptorType = DescriptorType::CS_INTERFACE;
      DescriptorSubtype bDescriptorSubtype = DescriptorSubtype::UNION;
      uint8_t bMasterInterface;  
      uint8_t bSlaveInterface0;  
    } cdc_union;
 
    EndpointDescriptor comm_ep;  
 
    InterfaceDescriptor data_intf;  
 
    EndpointDescriptor data_ep_out;  
    EndpointDescriptor data_ep_in;   
  } desc_block_;
#pragma pack(pop)
 
 protected:
  CDCLineCoding& GetLineCoding() { return line_coding_; }
 
  bool Inited() { return inited_; }
 
  Endpoint* GetDataInEndpoint() { return ep_data_in_; }
 
  Endpoint* GetDataOutEndpoint() { return ep_data_out_; }
 
  Endpoint* GetCommInEndpoint() { return ep_comm_in_; }
 
 private:
  // 端点号
  Endpoint::EPNumber data_in_ep_num_;   
  Endpoint::EPNumber data_out_ep_num_;  
  Endpoint::EPNumber comm_ep_num_;      
 
  // 端点指针
  Endpoint* ep_data_in_ = nullptr;   
  Endpoint* ep_data_out_ = nullptr;  
  Endpoint* ep_comm_in_ = nullptr;   
 
  // 端点回调
  LibXR::Callback<LibXR::ConstRawData&> on_data_out_complete_cb_ =
      LibXR::Callback<LibXR::ConstRawData&>::Create(OnDataOutCompleteStatic, this);
 
  LibXR::Callback<LibXR::ConstRawData&> on_data_in_complete_cb_ =
      LibXR::Callback<LibXR::ConstRawData&>::Create(OnDataInCompleteStatic, this);
 
  // 用户回调
  LibXR::Callback<bool, bool>
      on_set_control_line_state_cb_;  
  LibXR::Callback<LibXR::UART::Configuration>
      on_set_line_coding_cb_;  
 
  // 状态标志
  bool inited_ = false;  
 
  // 接口信息
  uint8_t itf_comm_in_num_;  
 
  // CDC参数
  CDCLineCoding line_coding_ = {115200, 0, 0, 8};  
  uint16_t control_line_state_ = 0;                
};
 
}  // namespace LibXR::USB