esp_cdc_jtag.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
 
#include "esp_def.hpp"
#include "esp_intr_alloc.h"
#include "esp_private/critical_section.h"
#include "serialized_service.hpp"
#include "soc/soc_caps.h"
#include "uart.hpp"
 
#if (SOC_USB_SERIAL_JTAG_SUPPORTED &&                                        \
     ((defined(CONFIG_IDF_TARGET_ESP32C3) && CONFIG_IDF_TARGET_ESP32C3) ||   \
      (defined(CONFIG_IDF_TARGET_ESP32C6) && CONFIG_IDF_TARGET_ESP32C6))) || \
    defined(__DOXYGEN__)
 
namespace LibXR
{
 
class ESP32CDCJtag;
 
class ESP32CDCJtagReadPort : public ReadPort
{
 public:
  explicit ESP32CDCJtagReadPort(size_t size, ESP32CDCJtag& owner)
      : ReadPort(size), owner_(owner)
  {
  }
 
 protected:
  void OnReadQueueSpaceAvailable(bool in_isr) override;
 
 private:
  ESP32CDCJtag& owner_;
};
 
#if defined(CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG) && CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG
static_assert(false,
              "ESP32CDCJtag conflicts with ESP-IDF primary USB Serial/JTAG console. "
              "Set CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=n or disable this backend.");
#endif
 
class ESP32CDCJtag : public UART
{
  friend class ESP32CDCJtagReadPort;
 
 public:
  explicit ESP32CDCJtag(size_t rx_buffer_size = 1024, size_t tx_buffer_size = 512,
                        uint32_t tx_queue_size = 5,
                        UART::Configuration config = {115200, UART::Parity::NO_PARITY, 8,
                                                      1});
 
  ErrorCode SetConfig(UART::Configuration config, bool in_isr = false) override;
 
  static void WriteFun(WritePort& port, bool in_isr);
 
 private:
  static constexpr uint32_t EVENT_WRITE = 1U << 0U;
  static constexpr uint32_t EVENT_TX_EMPTY = 1U << 1U;
  static constexpr uint32_t EVENT_RX_DATA = 1U << 2U;
  static constexpr uint32_t EVENT_RX_SPACE = 1U << 3U;
 
  static void IsrEntry(void* arg);
  ErrorCode InitHardware();
 
  void ServiceEvents(uint32_t events, bool in_isr);
  void ResumeRx(bool in_isr);
  void ServiceRx(ReadPort::ReadQueue& queue, bool in_isr);
  void DrainRxToQueue(ReadPort::ReadQueue& queue, bool in_isr);
  void PushRxBytes(ReadPort::ReadQueue& queue, const uint8_t* data, size_t size,
                   bool in_isr);
 
  void ProgressTx(bool in_isr);
  size_t FillTxFifo(WritePort::WriteQueue& queue, bool in_isr);
  void ArmTxEmptyInterrupt();
  void DisarmTxEmptyInterrupt();
  void FlushTxFifo();
  void HandleInterrupt();
 
  void EnableInterrupt(uint32_t mask);
  void DisableInterrupt(uint32_t mask);
  void ClearInterrupt(uint32_t mask);
  void DisableAndClearInterrupt(uint32_t mask);
  uint32_t CaptureInterrupt(uint32_t mask);
 
  intr_handle_t intr_handle_ = nullptr;
  bool hw_inited_ = false;
  bool tx_empty_interrupt_armed_ = false;
  bool tx_flush_pending_ = false;
 
  DECLARE_CRIT_SECTION_LOCK_IN_STRUCT(irq_lock_)
  SerializedService service_{};
  ESP32CDCJtagReadPort _read_port;
  WritePort _write_port;
};
 
}  // namespace LibXR
 
#endif