device_manager.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <etl/singleton.h>
 
#include <cassert>
 
#include "device_node.hpp"
#include "driver_registry.hpp"
#include "expected.hpp"
#include "kernel_log.hpp"
#include "spinlock.hpp"
 
class DeviceManager {
 public:
  template <Bus B>
  auto RegisterBus(B& bus) -> Expected<void> {
    LockGuard guard(lock_);
 
    if (device_count_ >= kMaxDevices) {
      return std::unexpected(Error(ErrorCode::kOutOfMemory));
    }
 
    size_t remaining = kMaxDevices - device_count_;
    auto result = bus.Enumerate(devices_ + device_count_, remaining);
    if (!result.has_value()) {
      klog::Err("DeviceManager: bus '{}' enumeration failed: {}", B::GetName(),
                result.error().message());
      return std::unexpected(result.error());
    }
 
    size_t count = result.value();
    for (size_t i = 0; i < count; ++i) {
      devices_[device_count_ + i].dev_id = next_dev_id_++;
      if (!name_index_.full()) {
        name_index_.insert(
            {devices_[device_count_ + i].name, device_count_ + i});
      }
    }
    device_count_ += count;
 
    klog::Info("DeviceManager: bus '{}' enumerated {} device(s)", B::GetName(),
               count);
    return {};
  }
 
  [[nodiscard]] auto ProbeAll() -> Expected<void>;
 
  [[nodiscard]] auto FindDevice(const char* name) -> Expected<DeviceNode*>;
 
  [[nodiscard]] auto FindDevicesByType(DeviceType type, DeviceNode** out,
                                       size_t max) -> size_t;
 
  [[nodiscard]] auto GetRegistry() -> DriverRegistry& { return registry_; }
 
  DeviceManager() = default;
  ~DeviceManager() = default;
  DeviceManager(const DeviceManager&) = delete;
  DeviceManager(DeviceManager&&) = delete;
  auto operator=(const DeviceManager&) -> DeviceManager& = delete;
  auto operator=(DeviceManager&&) -> DeviceManager& = delete;
 
 private:
  static constexpr size_t kMaxDevices = 64;
  DeviceNode devices_[kMaxDevices]{};
  size_t device_count_{0};
  uint32_t next_dev_id_{0};
  DriverRegistry registry_;
  SpinLock lock_{"device_manager"};
  etl::flat_map<const char*, size_t, kMaxDevices, CStrLess> name_index_;
};
 
using DeviceManagerSingleton = etl::singleton<DeviceManager>;