device_initializer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <utility>
 
#include "expected.hpp"
#include "kernel_log.hpp"
#include "virtio/transport/transport.hpp"
 
namespace virtio {
 
template <TransportConcept TransportImpl>
class DeviceInitializer {
 public:
  [[nodiscard]] auto Init(uint64_t driver_features) -> Expected<uint64_t> {
    if (!transport_.IsValid()) {
      return std::unexpected(Error{ErrorCode::kTransportNotInitialized});
    }
 
    transport_.Reset();
 
    transport_.SetStatus(
        std::to_underlying(Transport::DeviceStatus::kAcknowledge));
 
    transport_.SetStatus(
        std::to_underlying(Transport::DeviceStatus::kAcknowledge) |
        std::to_underlying(Transport::DeviceStatus::kDriver));
 
    uint64_t device_features = transport_.GetDeviceFeatures();
    uint64_t negotiated_features = device_features & driver_features;
 
    transport_.SetDriverFeatures(negotiated_features);
 
    transport_.SetStatus(
        std::to_underlying(Transport::DeviceStatus::kAcknowledge) |
        std::to_underlying(Transport::DeviceStatus::kDriver) |
        std::to_underlying(Transport::DeviceStatus::kFeaturesOk));
 
    uint32_t status = transport_.GetStatus();
    if ((status & std::to_underlying(Transport::DeviceStatus::kFeaturesOk)) ==
        0) {
      transport_.SetStatus(
          status | std::to_underlying(Transport::DeviceStatus::kFailed));
      return std::unexpected(Error{ErrorCode::kFeatureNegotiationFailed});
    }
 
    return negotiated_features;
  }
 
  [[nodiscard]] auto SetupQueue(uint32_t queue_idx, uint64_t desc_phys,
                                uint64_t avail_phys, uint64_t used_phys,
                                uint32_t queue_size) -> Expected<void> {
    if (!transport_.IsValid()) {
      return std::unexpected(Error{ErrorCode::kTransportNotInitialized});
    }
 
    uint32_t max_size = transport_.GetQueueNumMax(queue_idx);
    if (max_size == 0) {
      return std::unexpected(Error{ErrorCode::kQueueNotAvailable});
    }
    if (queue_size > max_size) {
      return std::unexpected(Error{ErrorCode::kQueueTooLarge});
    }
 
    transport_.SetQueueNum(queue_idx, queue_size);
    transport_.SetQueueDesc(queue_idx, desc_phys);
    transport_.SetQueueAvail(queue_idx, avail_phys);
    transport_.SetQueueUsed(queue_idx, used_phys);
    transport_.SetQueueReady(queue_idx, true);
 
    return {};
  }
 
  [[nodiscard]] auto Activate() -> Expected<void> {
    if (!transport_.IsValid()) {
      return std::unexpected(Error{ErrorCode::kTransportNotInitialized});
    }
 
    uint32_t current_status = transport_.GetStatus();
    transport_.SetStatus(
        current_status |
        std::to_underlying(Transport::DeviceStatus::kDriverOk));
 
    uint32_t new_status = transport_.GetStatus();
    if ((new_status &
         std::to_underlying(Transport::DeviceStatus::kDeviceNeedsReset)) != 0) {
      return std::unexpected(Error{ErrorCode::kDeviceError});
    }
 
    return {};
  }
 
  [[nodiscard]] auto transport() -> TransportImpl& { return transport_; }
 
  [[nodiscard]] auto transport() const -> const TransportImpl& {
    return transport_;
  }
 
 
  explicit DeviceInitializer(TransportImpl& transport)
      : transport_(transport) {}
  DeviceInitializer() = delete;
  DeviceInitializer(const DeviceInitializer&) = delete;
  DeviceInitializer(DeviceInitializer&&) = delete;
  auto operator=(const DeviceInitializer&) -> DeviceInitializer& = delete;
  auto operator=(DeviceInitializer&&) -> DeviceInitializer& = delete;
  ~DeviceInitializer() = default;
 
 private:
  TransportImpl& transport_;
};
 
}  // namespace virtio