desc_cfg.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
 
#include "core.hpp"
#include "desc_dev.hpp"
#include "ep_pool.hpp"
#include "lockfree_list.hpp"
#include "lockfree_pool.hpp"
 
namespace LibXR::USB
{
// USB 配置描述符属性标志（bmAttributes 位定义）
// USB configuration descriptor attribute bits (bmAttributes)
constexpr uint8_t CFG_BUS_POWERED = 0x80;    
constexpr uint8_t CFG_SELF_POWERED = 0x40;   
constexpr uint8_t CFG_REMOTE_WAKEUP = 0x20;  
 
class ConfigDescriptor;
 
class ConfigDescriptorItem
{
 public:
#pragma pack(push, 1)
  struct Header
  {
    uint8_t bLength = 9;      
    uint8_t bDescriptorType;  
    uint16_t wTotalLength;   
    uint8_t bNumInterfaces;  
    uint8_t bConfigurationValue;  
    uint8_t iConfiguration;       
    uint8_t bmAttributes;         
    uint8_t bMaxPower;            
  };
 
  struct IADDescriptor
  {
    uint8_t bLength = 8;             
    uint8_t bDescriptorType = 0x0B;  
    uint8_t bFirstInterface;         
    uint8_t bInterfaceCount;    
    uint8_t bFunctionClass;     
    uint8_t bFunctionSubClass;  
    uint8_t bFunctionProtocol;  
    uint8_t iFunction;          
  };
 
  struct InterfaceDescriptor
  {
    uint8_t bLength = 9;  
    uint8_t bDescriptorType =
        0x04;                   
    uint8_t bInterfaceNumber;   
    uint8_t bAlternateSetting;  
    uint8_t bNumEndpoints;      
    uint8_t bInterfaceClass;    
    uint8_t bInterfaceSubClass;  
    uint8_t bInterfaceProtocol;  
    uint8_t iInterface;          
  };
 
  struct EndpointDescriptor
  {
    uint8_t bLength = 7;  
    uint8_t bDescriptorType =
        0x05;                  
    uint8_t bEndpointAddress;  
    uint8_t bmAttributes;      
    uint16_t wMaxPacketSize;   
    uint8_t bInterval;  
  };
#pragma pack(pop)
 
  virtual void Init(EndpointPool& endpoint_pool, uint8_t start_itf_num) = 0;
 
  virtual void Deinit(EndpointPool& endpoint_pool) = 0;
 
  virtual ErrorCode WriteDeviceDescriptor(DeviceDescriptor& header)
  {
    UNUSED(header);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode SetAltSetting(uint8_t itf, uint8_t alt)
  {
    UNUSED(itf);
    if (alt == 0)
    {
      return ErrorCode::OK;
    }
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode GetAltSetting(uint8_t itf, uint8_t& alt)
  {
    UNUSED(itf);
    UNUSED(alt);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual size_t GetMaxConfigSize() = 0;
 
  virtual size_t GetInterfaceNum() = 0;
 
  virtual bool HasIAD() = 0;
 
 protected:
  RawData GetData();
 
  void SetData(RawData data) { data_ = data; }
 
  friend class ConfigDescriptor;
 
 private:
  RawData data_;  
};
 
class ConfigDescriptor
{
  using Header = ConfigDescriptorItem::Header;
 
  struct Config
  {
    ConfigDescriptorItem** items;
    size_t item_num;
  };
 
  static bool IsCompositeConfig(
      const std::initializer_list<const std::initializer_list<ConfigDescriptorItem*>>&
          configs);
 
 public:
  ConfigDescriptor(
      EndpointPool& endpoint_pool,
      const std::initializer_list<const std::initializer_list<ConfigDescriptorItem*>>&
          configs,
      uint8_t bmAttributes = CFG_BUS_POWERED, uint8_t bMaxPower = 50);
 
  ErrorCode SwitchConfig(size_t index);
 
  void AssignEndpoints();
 
  void ReleaseEndpoints();
 
  ErrorCode Generate();
 
  bool IsComposite() const;
 
  ErrorCode OverrideDeviceDescriptor(DeviceDescriptor& descriptor);
 
  RawData GetData() const;
 
  size_t GetConfigNum() const;
 
  size_t GetCurrentConfig() const;
 
  uint16_t GetDeviceStatus() const;
 
  ConfigDescriptorItem* GetItemByInterfaceNum(size_t index) const;
 
 private:
  bool ep_assigned_ = false;  
 
  EndpointPool& endpoint_pool_;   
  uint8_t current_cfg_ = 0;       
  uint8_t i_configuration_ = 0;   
  uint8_t bm_attributes_ = 0x80;  
  uint8_t b_max_power_ = 50;      
 
  const bool COMPOSITE = false;    
  const size_t CFG_NUM = 0;        
  Config* items_ = nullptr;        
  RawData buffer_ = {nullptr, 0};  
  size_t buffer_index_ = 0;        
};
 
}  // namespace LibXR::USB