virtio_driver.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <etl/io_port.h>
#include <etl/singleton.h>
#include <etl/span.h>
 
#include <array>
#include <optional>
#include <variant>
 
#include "device_manager.hpp"
#include "device_node.hpp"
#include "driver_registry.hpp"
#include "expected.hpp"
#include "io_buffer.hpp"
#include "kernel_log.hpp"
#include "kstd_memory"
#include "virtio/device/blk/virtio_blk.hpp"
#include "virtio/device/blk/virtio_blk_vfs_adapter.hpp"
 
class VirtioDriver {
 public:
  enum class DeviceId : uint32_t {
    kNet = 1,
    kBlock = 2,
    kConsole = 3,
    kEntropy = 4,
    kGpu = 16,
    kInput = 18,
  };
 
  static constexpr uint32_t kDefaultQueueCount = 1;
  static constexpr uint32_t kDefaultQueueSize = 128;
  static constexpr size_t kMinDmaBufferSize = 32768;
 
  [[nodiscard]] static auto GetEntry() -> const DriverEntry& {
    static const DriverEntry entry{
        .name = "virtio",
        .match_table = etl::span<const MatchEntry>(kMatchTable),
        .match = etl::delegate<bool(
            DeviceNode&)>::create<&VirtioDriver::MatchStatic>(),
        .probe = etl::delegate<Expected<void>(DeviceNode&)>::create<
            VirtioDriver, &VirtioDriver::Probe>(
            etl::singleton<VirtioDriver>::instance()),
        .remove = etl::delegate<Expected<void>(DeviceNode&)>::create<
            VirtioDriver, &VirtioDriver::Remove>(
            etl::singleton<VirtioDriver>::instance()),
    };
    return entry;
  }
 
  static auto MatchStatic(DeviceNode& node) -> bool;
 
  [[nodiscard]] auto Probe(DeviceNode& node) -> Expected<void>;
 
  [[nodiscard]] auto Remove([[maybe_unused]] DeviceNode& node)
      -> Expected<void> {
    for (size_t i = 0; i < blk_device_count_; ++i) {
      blk_devices_[i].reset();
      dma_buffers_[i].reset();
      slot_buffers_[i].reset();
    }
    blk_device_count_ = 0;
    blk_adapter_count_ = 0;
    return {};
  }
 
  [[nodiscard]] auto GetBlkDevice() -> virtio::blk::VirtioBlk<>* {
    return (blk_device_count_ > 0 && blk_devices_[0].has_value())
               ? &blk_devices_[0].value()
               : nullptr;
  }
 
  [[nodiscard]] auto GetIrq() const -> uint32_t {
    return blk_device_count_ > 0 ? irqs_[0] : 0;
  }
 
  template <typename CompletionCallback>
  auto HandleInterrupt(CompletionCallback&& on_complete) -> void {
    for (size_t i = 0; i < blk_device_count_; ++i) {
      if (blk_devices_[i].has_value()) {
        blk_devices_[i].value().HandleInterrupt(
            static_cast<CompletionCallback&&>(on_complete));
      }
    }
  }
 
  VirtioDriver() = default;
  VirtioDriver(const VirtioDriver&) = delete;
  VirtioDriver(VirtioDriver&&) = delete;
  auto operator=(const VirtioDriver&) -> VirtioDriver& = delete;
  auto operator=(VirtioDriver&&) -> VirtioDriver& = delete;
  ~VirtioDriver() = default;
 
 private:
  static constexpr MatchEntry kMatchTable[] = {
      {BusType::kPlatform, "virtio,mmio"},
  };
 
  static constexpr size_t kMaxBlkDevices = 4;
 
  std::array<std::optional<virtio::blk::VirtioBlk<>>, kMaxBlkDevices>
      blk_devices_;
  std::array<etl::unique_ptr<IoBuffer>, kMaxBlkDevices> dma_buffers_;
  std::array<etl::unique_ptr<IoBuffer>, kMaxBlkDevices> slot_buffers_;
  std::array<uint32_t, kMaxBlkDevices> irqs_{};
  size_t blk_device_count_{0};
 
  // Static adapter pool — one slot per probed blk device (kernel lifetime).
  std::array<std::optional<virtio::blk::VirtioBlkVfsAdapter>, kMaxBlkDevices>
      blk_adapters_;
  size_t blk_adapter_count_{0};
};
 
using VirtioDriverSingleton = etl::singleton<VirtioDriver>;