dev_core.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
 
#include "libxr_type.hpp"
#include "usb/core/core.hpp"
#include "usb/core/desc_cfg.hpp"
#include "usb/core/ep_pool.hpp"
 
namespace LibXR::USB
{
class DeviceCore;
 
class DeviceClass : public ConfigDescriptorItem
{
 public:
  explicit DeviceClass(std::initializer_list<BosCapability*> bos_caps = {});
 
  ~DeviceClass() override;
 
 protected:
  struct ControlTransferResult
  {
    RawData read_data{nullptr, 0};  
    ConstRawData write_data{nullptr, 0};  
    bool read_zlp = false;   
    bool write_zlp = false;  
 
    RawData& OutData() { return read_data; }
    const RawData& OutData() const { return read_data; }
 
    ConstRawData& InData() { return write_data; }
    const ConstRawData& InData() const { return write_data; }
 
    bool& ExpectStatusOutZLP() { return read_zlp; }
    bool ExpectStatusOutZLP() const { return read_zlp; }
 
    bool& SendStatusInZLP() { return write_zlp; }
    bool SendStatusInZLP() const { return write_zlp; }
  };
 
  virtual ErrorCode OnGetDescriptor(bool in_isr, uint8_t bRequest, uint16_t wValue,
                                    uint16_t wLength, ConstRawData& out_data)
  {
    UNUSED(in_isr);
    UNUSED(bRequest);
    UNUSED(wValue);
    UNUSED(wLength);
    UNUSED(out_data);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode OnClassRequest(bool in_isr, uint8_t bRequest, uint16_t wValue,
                                   uint16_t wLength, uint16_t wIndex,
                                   ControlTransferResult& result)
  {
    UNUSED(in_isr);
    UNUSED(bRequest);
    UNUSED(wValue);
    UNUSED(wLength);
    UNUSED(wIndex);
    UNUSED(result);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode OnClassData(bool in_isr, uint8_t bRequest, LibXR::ConstRawData& data)
  {
    UNUSED(in_isr);
    UNUSED(bRequest);
    UNUSED(data);
    return ErrorCode::NOT_SUPPORT;
  }
 
  virtual ErrorCode OnVendorRequest(bool in_isr, uint8_t bRequest, uint16_t wValue,
                                    uint16_t wLength, uint16_t wIndex,
                                    ControlTransferResult& result)
  {
    UNUSED(in_isr);
    UNUSED(bRequest);
    UNUSED(wValue);
    UNUSED(wLength);
    UNUSED(wIndex);
    UNUSED(result);
    return ErrorCode::NOT_SUPPORT;
  }
 
  friend class DeviceCore;
 
 private:
  BosCapability** bos_caps_ =
      nullptr;              
  size_t bos_cap_num_ = 0;  
};
 
class DeviceCore
{
 public:
  enum Context : uint8_t
  {
    UNKNOWN = 0,  
    SETUP,        
    DATA_OUT,     
    STATUS_OUT,   
    DATA_IN,      
    STATUS_IN,    
    ZLP           
  };
 
  DeviceCore(
      EndpointPool& ep_pool, USBSpec spec, Speed speed,
      DeviceDescriptor::PacketSize0 packet_size, uint16_t vid, uint16_t pid, uint16_t bcd,
      const std::initializer_list<const DescriptorStrings::LanguagePack*>& lang_list,
      const std::initializer_list<const std::initializer_list<ConfigDescriptorItem*>>&
          configs,
      ConstRawData uid = {nullptr, 0});
 
  virtual void Init(bool in_isr);
 
  virtual void Deinit(bool in_isr);
 
  virtual void Start(bool in_isr) = 0;
 
  virtual void Stop(bool in_isr) = 0;
 
  void OnSetupPacket(bool in_isr, const SetupPacket* setup);
 
 protected:
  virtual ErrorCode SetAddress(uint8_t address, Context state) = 0;
 
  virtual void EnableRemoteWakeup() {}
 
  virtual void DisableRemoteWakeup() {}
 
  virtual bool IsRemoteWakeupEnabled() const { return false; }
 
  [[nodiscard]] Speed GetSpeed() const;
 
 private:
  static void OnEP0OutCompleteStatic(bool in_isr, DeviceCore* self,
                                     LibXR::ConstRawData& data);
  static void OnEP0InCompleteStatic(bool in_isr, DeviceCore* self,
                                    LibXR::ConstRawData& data);
 
  static bool IsValidUSBCombination(USBSpec spec, Speed speed,
                                    DeviceDescriptor::PacketSize0 packet_size);
 
  void OnEP0OutComplete(bool in_isr, LibXR::ConstRawData& data);
  void OnEP0InComplete(bool in_isr, LibXR::ConstRawData& data);
 
  void ReadZLP(Context context = Context::ZLP);
  void WriteZLP(Context context = Context::ZLP);
 
  void DevWriteEP0Data(LibXR::ConstRawData data, size_t packet_max_length,
                       size_t request_size = 0, bool early_read_zlp = false);
  void DevReadEP0Data(LibXR::RawData data, size_t packet_max_length);
 
  ErrorCode ProcessStandardRequest(bool in_isr, const SetupPacket*& setup,
                                   RequestDirection direction, Recipient recipient);
 
  ErrorCode RespondWithStatus(const SetupPacket* setup, Recipient recipient);
  ErrorCode ClearFeature(const SetupPacket* setup, Recipient recipient);
  ErrorCode ApplyFeature(const SetupPacket* setup, Recipient recipient);
  ErrorCode SendDescriptor(bool in_isr, const SetupPacket* setup, Recipient recipient);
  ErrorCode PrepareAddressChange(uint16_t address);
  ErrorCode SwitchConfiguration(uint16_t value, bool in_isr);
  ErrorCode SendConfiguration();
 
  void StallControlEndpoint();
  void ClearControlEndpointStall();
 
  ErrorCode ProcessClassRequest(bool in_isr, const SetupPacket* setup,
                                RequestDirection direction, Recipient recipient);
 
  ErrorCode ProcessVendorRequest(bool in_isr, const SetupPacket*& setup,
                                 RequestDirection direction, Recipient recipient);
 
 private:
  ConfigDescriptor config_desc_;  
  DeviceDescriptor device_desc_;  
  DescriptorStrings strings_;     
 
  struct
  {
    EndpointPool& pool;        
    Endpoint* in0 = nullptr;   
    Endpoint* out0 = nullptr;  
    LibXR::Callback<LibXR::ConstRawData&> ep0_in_cb;  
    LibXR::Callback<LibXR::ConstRawData&>
        ep0_out_cb;  
  } endpoint_;
 
  struct
  {
    bool inited = false;                    
    Speed speed = Speed::FULL;              
    Context in0 = Context::UNKNOWN;         
    Context out0 = Context::UNKNOWN;        
    ConstRawData write_remain{nullptr, 0};  
    RawData read_remain{nullptr, 0};        
    uint8_t pending_addr = 0xFF;            
    uint8_t* out0_buffer = nullptr;         
    bool need_write_zlp = false;            
  } state_;
 
  struct
  {
    bool write = false;  
    bool read = false;   
    DeviceClass* class_ptr = nullptr;  
    uint8_t b_request = 0;             
    ConstRawData data{nullptr, 0};     
  } class_req_;
};
 
}  // namespace LibXR::USB