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 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
{
  using Header = ConfigDescriptorItem::Header;
 
 public:
  explicit ConfigDescriptor(size_t buffer_size, uint8_t bmAttributes = CFG_BUS_POWERED,
                            uint8_t bMaxPower = 50);
 
  ConfigDescriptor(const ConfigDescriptor&) = delete;
  ConfigDescriptor& operator=(const ConfigDescriptor&) = delete;
 
  static size_t CalcMaxConfigSize(
      const std::initializer_list<const std::initializer_list<ConfigDescriptorItem*>>&
          configs);
 
  ErrorCode BuildConfigDescriptor(ConfigDescriptorItem* const* items, size_t item_num,
                                  uint8_t configuration_value,
                                  uint8_t i_configuration = 0);
 
  [[nodiscard]] RawData GetData() const;
 
 private:
  uint8_t bm_attributes_ = CFG_BUS_POWERED;  
  uint8_t b_max_power_ = 50;  
 
  RawData buffer_{nullptr, 0};  
  size_t buffer_index_ = 0;     
};
 
}  // namespace LibXR::USB