mmio.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <utility>
 
#include "expected.hpp"
#include "kernel_log.hpp"
#include "mmio_accessor.hpp"
#include "virtio/transport/transport.hpp"
 
namespace virtio {
 
enum class InterruptStatus : uint32_t {
  kUsedBuffer = 0x01,
  kConfigChange = 0x02,
};
 
static constexpr uint32_t kMmioMagicValue = 0x74726976;
 
static constexpr uint32_t kMmioVersionModern = 0x02;
 
class MmioTransport final : public Transport {
 public:
  enum class MmioReg : size_t {
    kMagicValue = 0x000,
    kVersion = 0x004,
    kDeviceId = 0x008,
    kVendorId = 0x00C,
    kDeviceFeatures = 0x010,
    kDeviceFeaturesSel = 0x014,
    // 0x018 ~ 0x01F: reserved
    kDriverFeatures = 0x020,
    kDriverFeaturesSel = 0x024,
    // 0x028 ~ 0x02F: reserved
    kQueueSel = 0x030,
    kQueueNumMax = 0x034,
    kQueueNum = 0x038,
    // 0x03C ~ 0x03F: reserved
    // 0x040 ~ 0x043: reserved
    kQueueReady = 0x044,
    // 0x048 ~ 0x04F: reserved
    kQueueNotify = 0x050,
    // 0x054 ~ 0x05F: reserved
    kInterruptStatus = 0x060,
    kInterruptAck = 0x064,
    // 0x068 ~ 0x06F: reserved
    kStatus = 0x070,
    // 0x074 ~ 0x07F: reserved
    kQueueDescLow = 0x080,
    kQueueDescHigh = 0x084,
    // 0x088 ~ 0x08F: reserved
    kQueueDriverLow = 0x090,
    kQueueDriverHigh = 0x094,
    // 0x098 ~ 0x09F: reserved
    kQueueDeviceLow = 0x0A0,
    kQueueDeviceHigh = 0x0A4,
    // 0x0A8 ~ 0x0AB: reserved
    kShmSel = 0x0AC,
    kShmLenLow = 0x0B0,
    kShmLenHigh = 0x0B4,
    kShmBaseLow = 0x0B8,
    kShmBaseHigh = 0x0BC,
    kQueueReset = 0x0C0,
    // 0x0C4 ~ 0x0FB: reserved
    kConfigGeneration = 0x0FC,
    kConfig = 0x100,
  };
 
  explicit MmioTransport(uint64_t base)
      : mmio_(base), is_valid_(false), device_id_(0), vendor_id_(0) {
    if (base == 0) {
      return;
    }
 
    auto magic = mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kMagicValue));
    if (magic != kMmioMagicValue) {
      return;
    }
 
    auto version = mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kVersion));
    if (version != kMmioVersionModern) {
      return;
    }
 
    device_id_ = mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kDeviceId));
    if (device_id_ == 0) {
      return;
    }
 
    vendor_id_ = mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kVendorId));
    this->Reset();
    is_valid_ = true;
  }
 
  [[nodiscard]] auto IsValid() const -> bool { return is_valid_; }
 
  MmioTransport(MmioTransport&& other) noexcept
      : Transport(std::move(other)),
        mmio_(other.mmio_),
        is_valid_(other.is_valid_),
        device_id_(other.device_id_),
        vendor_id_(other.vendor_id_) {
    other.is_valid_ = false;
  }
  auto operator=(MmioTransport&&) noexcept -> MmioTransport& = delete;
  MmioTransport(const MmioTransport&) = delete;
  auto operator=(const MmioTransport&) -> MmioTransport& = delete;
 
  [[nodiscard]] auto GetDeviceId() const -> uint32_t { return device_id_; }
 
  [[nodiscard]] auto GetVendorId() const -> uint32_t { return vendor_id_; }
 
  [[nodiscard]] auto GetStatus() const -> uint32_t {
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kStatus));
  }
 
  auto SetStatus(uint32_t status) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kStatus), status);
  }
 
  [[nodiscard]] auto GetDeviceFeatures() -> uint64_t {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDeviceFeaturesSel), 0);
    uint64_t lo =
        mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kDeviceFeatures));
 
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDeviceFeaturesSel), 1);
    uint64_t hi =
        mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kDeviceFeatures));
 
    return (hi << 32) | lo;
  }
 
  auto SetDriverFeatures(uint64_t features) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDriverFeaturesSel), 0);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDriverFeatures),
                          static_cast<uint32_t>(features));
 
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDriverFeaturesSel), 1);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kDriverFeatures),
                          static_cast<uint32_t>(features >> 32));
  }
 
  [[nodiscard]] auto GetQueueNumMax(uint32_t queue_idx) -> uint32_t {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kQueueNumMax));
  }
 
  auto SetQueueNum(uint32_t queue_idx, uint32_t num) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueNum), num);
  }
 
  auto SetQueueDesc(uint32_t queue_idx, uint64_t addr) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDescLow),
                          static_cast<uint32_t>(addr));
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDescHigh),
                          static_cast<uint32_t>(addr >> 32));
  }
 
  auto SetQueueAvail(uint32_t queue_idx, uint64_t addr) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDriverLow),
                          static_cast<uint32_t>(addr));
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDriverHigh),
                          static_cast<uint32_t>(addr >> 32));
  }
 
  auto SetQueueUsed(uint32_t queue_idx, uint64_t addr) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDeviceLow),
                          static_cast<uint32_t>(addr));
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueDeviceHigh),
                          static_cast<uint32_t>(addr >> 32));
  }
 
  [[nodiscard]] auto GetQueueReady(uint32_t queue_idx) -> bool {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kQueueReady)) != 0;
  }
 
  auto SetQueueReady(uint32_t queue_idx, bool ready) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueSel), queue_idx);
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueReady),
                          ready ? 1 : 0);
  }
 
  auto NotifyQueue(uint32_t queue_idx) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kQueueNotify), queue_idx);
  }
 
  [[nodiscard]] auto GetInterruptStatus() const -> uint32_t {
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kInterruptStatus));
  }
 
  auto AckInterrupt(uint32_t ack_bits) -> void {
    mmio_.Write<uint32_t>(std::to_underlying(MmioReg::kInterruptAck), ack_bits);
  }
 
  [[nodiscard]] auto ReadConfigU8(uint32_t offset) const -> uint8_t {
    return mmio_.Read<uint8_t>(std::to_underlying(MmioReg::kConfig) + offset);
  }
 
  [[nodiscard]] auto ReadConfigU16(uint32_t offset) const -> uint16_t {
    return mmio_.Read<uint16_t>(std::to_underlying(MmioReg::kConfig) + offset);
  }
 
  [[nodiscard]] auto ReadConfigU32(uint32_t offset) const -> uint32_t {
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kConfig) + offset);
  }
 
  [[nodiscard]] auto ReadConfigU64(uint32_t offset) const -> uint64_t {
    uint32_t gen1;
    uint32_t gen2;
    uint64_t value;
 
    static constexpr uint32_t kMaxConfigRetries = 1000;
    uint32_t retries = 0;
    do {
      gen1 = GetConfigGeneration();
 
      auto* ptr = reinterpret_cast<volatile uint32_t*>(
          mmio_.base + std::to_underlying(MmioReg::kConfig) + offset);
      uint64_t lo = ptr[0];
      uint64_t hi = ptr[1];
      value = (hi << 32) | lo;
 
      gen2 = GetConfigGeneration();
    } while (gen1 != gen2 && ++retries < kMaxConfigRetries);
 
    return value;
  }
 
  [[nodiscard]] auto GetConfigGeneration() const -> uint32_t {
    return mmio_.Read<uint32_t>(std::to_underlying(MmioReg::kConfigGeneration));
  }
 
 private:
  MmioAccessor mmio_;
 
  bool is_valid_;
 
  uint32_t device_id_;
 
  uint32_t vendor_id_;
};
 
}  // namespace virtio