desc_cfg.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
 
#include "bos.hpp"
#include "core.hpp"
#include "desc_dev.hpp"
#include "ep_pool.hpp"
#include "libxr_type.hpp"
 
namespace LibXR::USB
{
constexpr uint8_t CFG_BUS_POWERED = 0x80;    
constexpr uint8_t CFG_SELF_POWERED = 0x40;   
constexpr uint8_t CFG_REMOTE_WAKEUP = 0x20;  
 
class ConfigDescriptor;
class DeviceCore;
 
class ConfigDescriptorItem : public BosCapabilityProvider
{
 public:
  virtual ~ConfigDescriptorItem() = default;
 
#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 BindEndpoints(EndpointPool& endpoint_pool, uint8_t start_itf_num,
                             bool in_isr) = 0;
 
  virtual void UnbindEndpoints(EndpointPool& endpoint_pool, bool in_isr) = 0;
 
  virtual ErrorCode WriteDeviceDescriptor(DeviceDescriptor& header)
  {
    UNUSED(header);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode SetAltSetting(uint8_t itf, uint8_t alt)
  {
    UNUSED(itf);
    return (alt == 0) ? ErrorCode::OK : ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode GetAltSetting(uint8_t itf, uint8_t& alt)
  {
    UNUSED(itf);
    UNUSED(alt);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual bool OwnsEndpoint(uint8_t ep_addr) const
  {
    UNUSED(ep_addr);
    return false;
  }
 
  virtual size_t GetMaxConfigSize() = 0;
 
  virtual size_t GetInterfaceCount() = 0;
 
  virtual bool HasIAD() = 0;
 
 protected:
  RawData GetData();
 
  void SetData(RawData data) { data_ = data; }
 
  friend class ConfigDescriptor;
 
 private:
  RawData data_{nullptr, 0};  
};
 
class ConfigDescriptor : public BosManager
{
  using Header = ConfigDescriptorItem::Header;
 
  struct Config
  {
    ConfigDescriptorItem** items = nullptr;  
    size_t item_num = 0;                     
  };
 
  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, bool in_isr);
 
  void BindEndpoints(bool in_isr);
 
  void UnbindEndpoints(bool in_isr);
 
  ErrorCode BuildConfigDescriptor();
 
  [[nodiscard]] bool IsComposite() const;
 
  void RebuildBosCache();
 
  [[nodiscard]] bool CanOverrideDeviceDescriptor() const;
 
  ErrorCode OverrideDeviceDescriptor(DeviceDescriptor& descriptor);
 
  [[nodiscard]] RawData GetData() const;
 
  [[nodiscard]] size_t GetConfigNum() const;
 
  [[nodiscard]] size_t GetCurrentConfig() const;
 
  [[nodiscard]] uint16_t GetDeviceStatus() const;
 
  [[nodiscard]] ConfigDescriptorItem* FindItemByInterfaceNumber(size_t index) const;
 
  [[nodiscard]] ConfigDescriptorItem* FindItemByEndpointAddress(uint8_t addr) const;
 
 private:
  bool ep_assigned_ = false;  
 
  EndpointPool& endpoint_pool_;  
  uint8_t current_cfg_ = 0;      
  uint8_t i_configuration_ = 0;  
  uint8_t bm_attributes_ = CFG_BUS_POWERED;  
  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