jtag_protocol.hpp

// jtag_protocol.hpp
#pragma once
 
#include <cstdint>
 
namespace LibXR::Debug::JtagProtocol
{
enum class Port : uint8_t
{
  DP = 0,  
  AP = 1,  
};
 
enum class Ack : uint8_t
{
  NO_ACK = 0x0,    
  OK = 0x1,        
  WAIT = 0x2,      
  FAULT = 0x4,     
  PROTOCOL = 0x7,  
};
 
struct Request
{
  Port port = Port::DP;  
  bool rnw =
      true;  
  uint8_t addr2b = 0;  
  uint32_t wdata = 0;  
};
 
struct Response
{
  Ack ack = Ack::PROTOCOL;  
  uint32_t rdata = 0;  
};
 
inline constexpr uint32_t JTAG_IR_ABORT = 0x08u;
inline constexpr uint32_t JTAG_IR_DPACC = 0x0Au;
inline constexpr uint32_t JTAG_IR_APACC = 0x0Bu;
inline constexpr uint32_t JTAG_IR_IDCODE = 0x0Eu;
inline constexpr uint32_t JTAG_IR_BYPASS = 0x0Fu;
 
inline constexpr uint8_t JTAG_SEQUENCE_TCK = 0x3Fu;  
inline constexpr uint8_t JTAG_SEQUENCE_TMS = 0x40u;  
inline constexpr uint8_t JTAG_SEQUENCE_TDO = 0x80u;  
 
inline constexpr uint32_t JTAG_DP_DR_LEN = 35u;
 
constexpr Ack map_jtag_ack(uint8_t raw_ack)
{
  switch (raw_ack & 0x7u)
  {
    case 0x2:
      return Ack::OK;
    case 0x1:
      return Ack::WAIT;
    case 0x4:
      return Ack::FAULT;
    case 0x0:
      return Ack::NO_ACK;
    default:
      return Ack::PROTOCOL;
  }
}
 
struct ChainConfig
{
  uint8_t count = 0;  
  uint8_t index = 0;  
  const uint8_t* ir_length = nullptr;   
  const uint16_t* ir_before = nullptr;  
  const uint16_t* ir_after = nullptr;   
 
  // 运行期缓存（可选）：用于减少每次 Shift 计算
  uint32_t ir_before_bits_len = 0;  
  uint32_t ir_after_bits_len = 0;   
  uint32_t dr_before_bits_len = 0;  
  uint32_t dr_after_bits_len = 0;   
};
 
inline void UpdateChainCache(ChainConfig& cfg)
{
  cfg.ir_before_bits_len = 0;
  cfg.ir_after_bits_len = 0;
  cfg.dr_before_bits_len = 0;
  cfg.dr_after_bits_len = 0;
 
  if (cfg.count == 0 || cfg.index >= cfg.count)
  {
    return;
  }
 
  if (cfg.ir_length != nullptr)
  {
    for (uint8_t i = 0; i < cfg.index; ++i)
    {
      cfg.ir_before_bits_len += cfg.ir_length[i];
    }
    for (uint8_t i = static_cast<uint8_t>(cfg.index + 1u); i < cfg.count; ++i)
    {
      cfg.ir_after_bits_len += cfg.ir_length[i];
    }
  }
 
  cfg.dr_before_bits_len = cfg.index;
  cfg.dr_after_bits_len = static_cast<uint32_t>(cfg.count - cfg.index - 1u);
}
 
inline uint64_t PackDpDr(const Request& req)
{
  const uint64_t RNW = req.rnw ? 1u : 0u;
  const uint64_t A2 = static_cast<uint64_t>(req.addr2b & 0x1u);
  const uint64_t A3 = static_cast<uint64_t>((req.addr2b >> 1) & 0x1u);
  return (static_cast<uint64_t>(req.wdata) << 3) | (A3 << 2) | (A2 << 1) | RNW;
}
 
inline void UnpackDpDr(uint64_t dr_lsb_first, Response& resp)
{
  const uint8_t RAW_ACK = static_cast<uint8_t>(dr_lsb_first & 0x7u);
  resp.ack = map_jtag_ack(RAW_ACK);
  resp.rdata = static_cast<uint32_t>((dr_lsb_first >> 3) & 0xFFFF'FFFFu);
}
 
constexpr Request make_dp_req(bool rnw, uint8_t addr2b, uint32_t wdata = 0u)
{
  return Request{Port::DP, rnw, static_cast<uint8_t>(addr2b & 0x03u), wdata};
}
 
constexpr Request make_ap_req(bool rnw, uint8_t addr2b, uint32_t wdata = 0u)
{
  return Request{Port::AP, rnw, static_cast<uint8_t>(addr2b & 0x03u), wdata};
}
 
}  // namespace LibXR::Debug::JtagProtocol