transport.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <utility>
 
#include "expected.hpp"
#include "virtio/defs.h"
 
namespace virtio {
 
template <typename T>
concept TransportConcept =
    requires(T t, const T ct, uint32_t u32, uint64_t u64) {
      // 设备有效性
      { ct.IsValid() } -> std::same_as<bool>;
 
      // 设备/供应商标识
      { ct.GetDeviceId() } -> std::same_as<uint32_t>;
      { ct.GetVendorId() } -> std::same_as<uint32_t>;
 
      // 设备状态
      { ct.GetStatus() } -> std::same_as<uint32_t>;
      { t.SetStatus(u32) } -> std::same_as<void>;
 
      // 特性协商（非 const：MMIO 需写选择器寄存器）
      { t.GetDeviceFeatures() } -> std::same_as<uint64_t>;
      { t.SetDriverFeatures(u64) } -> std::same_as<void>;
 
      // 队列配置（非 const：MMIO 需写 QueueSel）
      { t.GetQueueNumMax(u32) } -> std::same_as<uint32_t>;
      { t.SetQueueNum(u32, u32) } -> std::same_as<void>;
      { t.SetQueueDesc(u32, u64) } -> std::same_as<void>;
      { t.SetQueueAvail(u32, u64) } -> std::same_as<void>;
      { t.SetQueueUsed(u32, u64) } -> std::same_as<void>;
      { t.GetQueueReady(u32) } -> std::same_as<bool>;
      { t.SetQueueReady(u32, static_cast<bool>(true)) } -> std::same_as<void>;
 
      // 队列通知
      { t.NotifyQueue(u32) } -> std::same_as<void>;
 
      // 中断处理
      { ct.GetInterruptStatus() } -> std::same_as<uint32_t>;
      { t.AckInterrupt(u32) } -> std::same_as<void>;
 
      // 配置空间读取
      { ct.ReadConfigU8(u32) } -> std::same_as<uint8_t>;
      { ct.ReadConfigU16(u32) } -> std::same_as<uint16_t>;
      { ct.ReadConfigU32(u32) } -> std::same_as<uint32_t>;
      { ct.ReadConfigU64(u32) } -> std::same_as<uint64_t>;
      { ct.GetConfigGeneration() } -> std::same_as<uint32_t>;
    };
 
class Transport {
 public:
  enum class DeviceStatus : uint32_t {
    kReset = 0,
    kAcknowledge = 1,
    kDriver = 2,
    kDriverOk = 4,
    kFeaturesOk = 8,
    kDeviceNeedsReset = 64,
    kFailed = 128,
  };
 
  auto Reset(this auto&& self) -> void {
    self.SetStatus(std::to_underlying(DeviceStatus::kReset));
  }
 
  [[nodiscard]] auto NeedsReset(this auto const& self) -> bool {
    return (self.GetStatus() &
            std::to_underlying(DeviceStatus::kDeviceNeedsReset)) != 0;
  }
 
  [[nodiscard]] auto IsActive(this auto const& self) -> bool {
    return (self.GetStatus() & std::to_underlying(DeviceStatus::kDriverOk)) !=
           0;
  }
 
  auto AcknowledgeInterrupt(this auto&& self) -> void {
    auto status = self.GetInterruptStatus();
    if (status != 0) {
      self.AckInterrupt(status);
    }
  }
 
 protected:
  Transport() = default;
  ~Transport() = default;
  Transport(Transport&&) noexcept = default;
  auto operator=(Transport&&) noexcept -> Transport& = default;
  Transport(const Transport&) = delete;
  auto operator=(const Transport&) -> Transport& = delete;
};
 
}  // namespace virtio