dev_core.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <initializer_list>
 
#include "device_class.hpp"
#include "device_composition.hpp"
#include "libxr_type.hpp"
#include "usb/core/core.hpp"
#include "usb/core/ep_pool.hpp"
 
namespace LibXR::USB
{
 
class DeviceCore
{
 public:
  enum Context : uint8_t
  {
    UNKNOWN = 0,          
    SETUP_BEFORE_STATUS,  
    STATUS_IN_ARMED,      
    DATA_OUT,             
    STATUS_OUT,           
    DATA_IN,              
    STATUS_IN_COMPLETE,   
    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);
 
  [[nodiscard]] bool IsInited() const { return state_.inited; }
 
 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 ResetControlTransferState();
 
  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);
  void ArmStatusOutIfNeeded();
 
  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();
  void ResetClassRequestState();
 
  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:
  DeviceComposition composition_;  
  DeviceDescriptor device_desc_;   
 
  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;            
    bool status_out_armed =
        false;  
  } state_;
 
  struct
  {
    bool write = false;  
    bool read = false;   
    bool class_in_data_status_pending =
        false;  
    DeviceClass* class_ptr = nullptr;  
    uint8_t b_request = 0;             
    ConstRawData data{nullptr, 0};     
  } class_req_;
};
 
}  // namespace LibXR::USB