bos.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "desc_dev.hpp"
#include "libxr_def.hpp"
#include "libxr_type.hpp"
#include "usb/core/core.hpp"
 
namespace LibXR::USB
{
enum class DevCapabilityType : uint8_t
{
  USB20_EXTENSION = 0x02,  
};
 
static constexpr uint8_t DESCRIPTOR_TYPE_BOS =
    static_cast<uint8_t>(DescriptorType::BOS);  
 
static constexpr uint8_t DESCRIPTOR_TYPE_DEVICE_CAPABILITY = static_cast<uint8_t>(
    DescriptorType::DEVICE_CAPABILITY);  
 
static constexpr uint8_t DEV_CAPABILITY_TYPE_USB20EXT = static_cast<uint8_t>(
    DevCapabilityType::USB20_EXTENSION);  
 
static constexpr size_t BOS_HEADER_SIZE =
    5;  
static constexpr size_t USB2_EXT_CAP_SIZE =
    7;  
 
struct BosVendorResult
{
  bool handled = false;              
  ConstRawData in_data{nullptr, 0};  
  bool write_zlp = false;            
  bool early_read_zlp =
      true;  
};
 
class BosCapability
{
 public:
  virtual ~BosCapability() = default;
 
  virtual ConstRawData GetCapabilityDescriptor() const = 0;
 
  virtual ErrorCode OnVendorRequest(bool /*in_isr*/, const SetupPacket* /*setup*/,
                                    BosVendorResult& /*result*/)
  {
    return ErrorCode::NOT_SUPPORT;
  }
};
 
class BosCapabilityProvider
{
 public:
  virtual ~BosCapabilityProvider() = default;
 
  virtual size_t GetBosCapabilityCount() { return 0; }
 
  virtual BosCapability* GetBosCapability(size_t index)
  {
    UNUSED(index);
    return nullptr;
  }
};
 
class BosManager
{
 public:
  BosManager(size_t buffer_size, size_t cap_num)
      : cap_capacity_(cap_num),
        caps_(new BosCapability*[cap_num]),
        bos_buffer_({new uint8_t[buffer_size], buffer_size})
  {
  }
 
  ~BosManager()
  {
    delete[] caps_;
    caps_ = nullptr;
 
    delete[] reinterpret_cast<uint8_t*>(bos_buffer_.addr_);
    bos_buffer_ = {nullptr, 0};
 
    cap_capacity_ = 0;
    count_ = 0;
    bos_desc_size_ = 0;
  }
 
  BosManager(const BosManager&) = delete;
  BosManager& operator=(const BosManager&) = delete;
 
  void ClearCapabilities()
  {
    count_ = 0;
    bos_desc_size_ = 0;
  }
 
  bool AddCapability(BosCapability* cap)
  {
    ASSERT(bos_buffer_.addr_);
    ASSERT(cap != nullptr);
    ASSERT(count_ < cap_capacity_);
 
    caps_[count_++] = cap;
    return true;
  }
 
  ConstRawData GetBosDescriptor()
  {
    ASSERT(bos_buffer_.addr_);
 
    bool has_usb2_ext = false;
    for (size_t i = 0; i < count_; ++i)
    {
      ConstRawData blk = caps_[i]->GetCapabilityDescriptor();
      ASSERT(blk.addr_ != nullptr);
      ASSERT(blk.size_ >= 3);
 
      const uint8_t* p = reinterpret_cast<const uint8_t*>(blk.addr_);
      if (p[1] == DESCRIPTOR_TYPE_DEVICE_CAPABILITY &&
          p[2] == DEV_CAPABILITY_TYPE_USB20EXT)
      {
        has_usb2_ext = true;
      }
    }
 
    static constexpr uint8_t USB2_EXT_CAP[USB2_EXT_CAP_SIZE] = {7,    0x10, 0x02, 0x00,
                                                                0x00, 0x00, 0x00};
    const bool NEED_AUTO_USB2_EXT = !has_usb2_ext;
 
    size_t total = BOS_HEADER_SIZE;
    for (size_t i = 0; i < count_; ++i)
    {
      ConstRawData blk = caps_[i]->GetCapabilityDescriptor();
      ASSERT(blk.addr_ != nullptr);
      ASSERT(blk.size_ >= 1);
      total += blk.size_;
    }
    if (NEED_AUTO_USB2_EXT)
    {
      total += sizeof(USB2_EXT_CAP);
    }
 
    ASSERT(total <= bos_buffer_.size_);
    ASSERT(total <= 0xFFFF);
 
    auto buffer = reinterpret_cast<uint8_t*>(bos_buffer_.addr_);
 
    buffer[0] = static_cast<uint8_t>(BOS_HEADER_SIZE);
    buffer[1] = DESCRIPTOR_TYPE_BOS;
    buffer[2] = static_cast<uint8_t>(total & 0xFF);
    buffer[3] = static_cast<uint8_t>((total >> 8) & 0xFF);
    buffer[4] = static_cast<uint8_t>(count_ + (NEED_AUTO_USB2_EXT ? 1 : 0));
 
    size_t offset = BOS_HEADER_SIZE;
 
    for (size_t i = 0; i < count_; ++i)
    {
      ConstRawData blk = caps_[i]->GetCapabilityDescriptor();
      ASSERT(offset + blk.size_ <= bos_buffer_.size_);
 
      LibXR::Memory::FastCopy(&buffer[offset], blk.addr_, blk.size_);
      offset += blk.size_;
    }
 
    if (NEED_AUTO_USB2_EXT)
    {
      ASSERT(offset + sizeof(USB2_EXT_CAP) <= bos_buffer_.size_);
      LibXR::Memory::FastCopy(&buffer[offset], USB2_EXT_CAP, sizeof(USB2_EXT_CAP));
      offset += sizeof(USB2_EXT_CAP);
    }
 
    bos_desc_size_ = offset;
    return {buffer, offset};
  }
 
  ErrorCode ProcessVendorRequest(bool in_isr, const SetupPacket* setup,
                                 BosVendorResult& result)
  {
    if (setup == nullptr)
    {
      return ErrorCode::ARG_ERR;
    }
 
    for (size_t i = 0; i < count_; ++i)
    {
      BosVendorResult tmp{};
      auto ec = caps_[i]->OnVendorRequest(in_isr, setup, tmp);
 
      if (ec == ErrorCode::NOT_SUPPORT)
      {
        continue;
      }
      if (ec != ErrorCode::OK)
      {
        return ec;
      }
      if (tmp.handled)
      {
        result = tmp;
        return ErrorCode::OK;
      }
      return ErrorCode::FAILED;
    }
 
    return ErrorCode::NOT_SUPPORT;
  }
 
 private:
  size_t cap_capacity_ = 0;         
  BosCapability** caps_ = nullptr;  
  size_t count_ = 0;                
 
  size_t bos_desc_size_ = 0;           
  RawData bos_buffer_ = {nullptr, 0};  
};
 
}  // namespace LibXR::USB