swd.hpp

#pragma once
 
#include <cstdint>
 
#include "libxr_def.hpp"
#include "swd_protocol.hpp"
 
namespace LibXR::Debug
{
class Swd
{
 public:
  struct TransferPolicy
  {
    uint8_t idle_cycles = 0;    
    uint16_t wait_retry = 100;  
    bool clear_sticky_on_fault =
        true;  
  };
 
  virtual ~Swd() = default;
 
  Swd(const Swd&) = delete;
  Swd& operator=(const Swd&) = delete;
 
  void SetTransferPolicy(const TransferPolicy& policy) { policy_ = policy; }
 
  [[nodiscard]] const TransferPolicy& GetTransferPolicy() const { return policy_; }
 
  virtual ErrorCode SetClockHz(uint32_t hz) = 0;
 
  virtual void Close() = 0;
 
  virtual ErrorCode LineReset() = 0;
 
  virtual ErrorCode EnterSwd() = 0;
 
  virtual ErrorCode Transfer(const SwdProtocol::Request& req,
                             SwdProtocol::Response& resp) = 0;
 
  // --------------------------------------------------------------------------
  // Retry wrapper
  // --------------------------------------------------------------------------
 
  ErrorCode TransferWithRetry(const SwdProtocol::Request& req,
                              SwdProtocol::Response& resp)
  {
    ResetResponse(resp);
 
    uint32_t retries = 0;
 
    while (true)
    {
      auto ec = Transfer(req, resp);
      if (ec != ErrorCode::OK)
      {
        resp.ack = SwdProtocol::Ack::PROTOCOL;
        InvalidateSelectCache();
        return ec;
      }
 
      // CMSIS-DAP IdleCycles：每次传输尝试后插入。CMSIS-DAP IdleCycles: insert after EACH
      // transfer attempt.
      if (policy_.idle_cycles != 0u)
      {
        IdleClocks(policy_.idle_cycles);
      }
 
      if (resp.ack != SwdProtocol::Ack::WAIT)
      {
        break;
      }
      if (retries >= policy_.wait_retry)
      {
        break;
      }
      ++retries;
    }
 
    if (resp.ack != SwdProtocol::Ack::OK)
    {
      InvalidateSelectCache();
    }
 
    if (resp.ack == SwdProtocol::Ack::FAULT && policy_.clear_sticky_on_fault)
    {
      (void)ClearStickyErrors();
    }
 
    return ErrorCode::OK;
  }
 
  // --------------------------------------------------------------------------
  // DP/AP helpers
  // --------------------------------------------------------------------------
 
  ErrorCode DpRead(SwdProtocol::DpReadReg reg, uint32_t& val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC = Transfer(SwdProtocol::make_dp_read_req(reg), resp);
    if (EC != ErrorCode::OK)
    {
      ack = SwdProtocol::Ack::PROTOCOL;
      return EC;
    }
 
    ack = resp.ack;
 
    if (resp.ack != SwdProtocol::Ack::OK || !resp.parity_ok)
    {
      return ErrorCode::FAILED;
    }
 
    val = resp.rdata;
    return ErrorCode::OK;
  }
 
  ErrorCode DpWrite(SwdProtocol::DpWriteReg reg, uint32_t val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC = Transfer(SwdProtocol::make_dp_write_req(reg, val), resp);
    if (EC != ErrorCode::OK)
    {
      ack = SwdProtocol::Ack::PROTOCOL;
      return EC;
    }
 
    ack = resp.ack;
    return (resp.ack == SwdProtocol::Ack::OK) ? ErrorCode::OK : ErrorCode::FAILED;
  }
 
  ErrorCode DpReadTxn(SwdProtocol::DpReadReg reg, uint32_t& val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC = TransferWithRetry(SwdProtocol::make_dp_read_req(reg), resp);
    ack = resp.ack;
 
    if (EC != ErrorCode::OK)
    {
      return EC;
    }
 
    if (resp.ack != SwdProtocol::Ack::OK || !resp.parity_ok)
    {
      return ErrorCode::FAILED;
    }
 
    val = resp.rdata;
    return ErrorCode::OK;
  }
 
  ErrorCode DpWriteTxn(SwdProtocol::DpWriteReg reg, uint32_t val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC =
        TransferWithRetry(SwdProtocol::make_dp_write_req(reg, val), resp);
    ack = resp.ack;
 
    if (EC != ErrorCode::OK)
    {
      return EC;
    }
 
    return (resp.ack == SwdProtocol::Ack::OK) ? ErrorCode::OK : ErrorCode::FAILED;
  }
 
  ErrorCode ApReadTxn(uint8_t addr2b, uint32_t& val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC = TransferWithRetry(SwdProtocol::make_ap_read_req(addr2b), resp);
    ack = resp.ack;
 
    if (EC != ErrorCode::OK)
    {
      return EC;
    }
    if (resp.ack != SwdProtocol::Ack::OK)
    {
      return ErrorCode::FAILED;
    }
 
    return DpReadTxn(SwdProtocol::DpReadReg::RDBUFF, val, ack);
  }
 
  ErrorCode ApReadPostedTxn(uint8_t addr2b, uint32_t& posted_val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC = TransferWithRetry(SwdProtocol::make_ap_read_req(addr2b), resp);
    ack = resp.ack;
 
    if (EC != ErrorCode::OK)
    {
      return EC;
    }
    if (resp.ack != SwdProtocol::Ack::OK || !resp.parity_ok)
    {
      return ErrorCode::FAILED;
    }
 
    posted_val = resp.rdata;
    return ErrorCode::OK;
  }
 
  ErrorCode DpReadRdbuffTxn(uint32_t& val, SwdProtocol::Ack& ack)
  {
    return DpReadTxn(SwdProtocol::DpReadReg::RDBUFF, val, ack);
  }
 
  ErrorCode ApWriteTxn(uint8_t addr2b, uint32_t val, SwdProtocol::Ack& ack)
  {
    SwdProtocol::Response resp;
    const ErrorCode EC =
        TransferWithRetry(SwdProtocol::make_ap_write_req(addr2b, val), resp);
    ack = resp.ack;
 
    if (EC != ErrorCode::OK)
    {
      return EC;
    }
 
    return (resp.ack == SwdProtocol::Ack::OK) ? ErrorCode::OK : ErrorCode::FAILED;
  }
 
  ErrorCode ReadIdCode(uint32_t& idcode, SwdProtocol::Ack& ack)
  {
    return DpRead(SwdProtocol::DpReadReg::IDCODE, idcode, ack);
  }
 
  ErrorCode WriteAbort(uint32_t flags, SwdProtocol::Ack& ack)
  {
    return DpWrite(SwdProtocol::DpWriteReg::ABORT, flags, ack);
  }
 
  ErrorCode WriteAbortTxn(uint32_t flags, SwdProtocol::Ack& ack)
  {
    return DpWriteTxn(SwdProtocol::DpWriteReg::ABORT, flags, ack);
  }
 
  // --------------------------------------------------------------------------
  // SELECT cache
  // --------------------------------------------------------------------------
 
  ErrorCode SetSelectCached(uint32_t select, SwdProtocol::Ack& ack)
  {
    if (select_valid_ && (select_cache_ == select))
    {
      ack = SwdProtocol::Ack::OK;
      return ErrorCode::OK;
    }
 
    const ErrorCode EC = DpWriteTxn(SwdProtocol::DpWriteReg::SELECT, select, ack);
    if (EC == ErrorCode::OK && ack == SwdProtocol::Ack::OK)
    {
      select_cache_ = select;
      select_valid_ = true;
    }
    return EC;
  }
 
  void InvalidateSelectCache()
  {
    select_valid_ = false;
    select_cache_ = 0u;
  }
 
 public:
  Swd() = default;
 
  virtual void IdleClocks(uint32_t cycles) = 0;
 
  // 输出：在 SWDIO 上按 LSB-first 输出 data，并产生 SWCLK 脉冲。
  // cycles: 位数（例如 1..256）；data_lsb_first 长度 >= (cycles+7)/8
  virtual ErrorCode SeqWriteBits(uint32_t cycles, const uint8_t* data_lsb_first) = 0;
 
  // 输入：产生 SWCLK 脉冲并采样 SWDIO，按 LSB-first 写入 out_lsb_first。
  // out_lsb_first 长度 >= (cycles+7)/8
  virtual ErrorCode SeqReadBits(uint32_t cycles, uint8_t* out_lsb_first) = 0;
 
 private:
  static inline void ResetResponse(SwdProtocol::Response& resp)
  {
    resp.ack = SwdProtocol::Ack::PROTOCOL;
    resp.rdata = 0u;
    resp.parity_ok = true;
  }
 
  ErrorCode ClearStickyErrors()
  {
    SwdProtocol::Ack ack = SwdProtocol::Ack::NO_ACK;
    const uint32_t FLAGS =
        SwdProtocol::DP_ABORT_STKCMPCLR | SwdProtocol::DP_ABORT_STKERRCLR |
        SwdProtocol::DP_ABORT_WDERRCLR | SwdProtocol::DP_ABORT_ORUNERRCLR;
    return DpWrite(SwdProtocol::DpWriteReg::ABORT, FLAGS, ack);
  }
 
 private:
  TransferPolicy policy_{};  
 
  uint32_t select_cache_ = 0u;  
  bool select_valid_ = false;   
};
 
}  // namespace LibXR::Debug