driver_registry.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <etl/delegate.h>
#include <etl/flat_map.h>
#include <etl/span.h>
#include <etl/vector.h>
 
#include <cassert>
#include <cstddef>
#include <cstdint>
 
#include "device_node.hpp"
#include "expected.hpp"
#include "kernel.h"
#include "kernel_log.hpp"
#include "kstd_cstring"
#include "spinlock.hpp"
#include "virtual_memory.hpp"
 
struct MatchEntry {
  BusType bus_type{BusType::kPlatform};
  const char* compatible{nullptr};
};
 
struct DriverEntry {
  const char* name{nullptr};
  etl::span<const MatchEntry> match_table{};
  etl::delegate<bool(DeviceNode&)> match{};
  etl::delegate<Expected<void>(DeviceNode&)> probe{};
  etl::delegate<Expected<void>(DeviceNode&)> remove{};
};
 
struct CStrLess {
  auto operator()(const char* a, const char* b) const -> bool {
    return kstd::strcmp(a, b) < 0;
  }
};
 
class DriverRegistry {
 public:
  [[nodiscard]] auto Register(const DriverEntry& entry) -> Expected<void> {
    LockGuard guard(lock_);
    if (drivers_.full()) {
      return std::unexpected(Error(ErrorCode::kOutOfMemory));
    }
    const size_t idx = drivers_.size();
    for (const auto& me : entry.match_table) {
      if (compat_map_.full()) {
        return std::unexpected(Error(ErrorCode::kOutOfMemory));
      }
      // 重复键时 insert() 为空操作 — 先注册的驱动优先。
      compat_map_.insert({me.compatible, idx});
    }
    drivers_.push_back(entry);
    return {};
  }
 
  [[nodiscard]] auto FindDriver(const DeviceNode& node) -> const DriverEntry* {
    // 遍历节点的 compatible 字符串列表，对每个字符串执行 flat_map 查找。
    const char* p = node.compatible;
    const char* end = node.compatible + node.compatible_len;
    while (p < end) {
      const auto it = compat_map_.find(p);
      if (it != compat_map_.end()) {
        auto& entry = drivers_[it->second];
        if (entry.match(const_cast<DeviceNode&>(node))) {
          return &entry;
        }
      }
      p += kstd::strlen(p) + 1;
    }
    return nullptr;
  }
 
  DriverRegistry() = default;
  ~DriverRegistry() = default;
  DriverRegistry(const DriverRegistry&) = delete;
  DriverRegistry(DriverRegistry&&) = delete;
  auto operator=(const DriverRegistry&) -> DriverRegistry& = delete;
  auto operator=(DriverRegistry&&) -> DriverRegistry& = delete;
 
 private:
  static constexpr size_t kMaxDrivers = 32;
  static constexpr size_t kMaxCompatEntries = 96;
 
  etl::vector<DriverEntry, kMaxDrivers> drivers_;
  etl::flat_map<const char*, size_t, kMaxCompatEntries, CStrLess> compat_map_;
  SpinLock lock_{"driver_registry"};
};
 
namespace mmio_helper {
 
struct ProbeContext {
  uint64_t base{0};
  size_t size{0};
};
 
[[nodiscard]] inline auto Prepare(const DeviceNode& node, size_t default_size)
    -> Expected<ProbeContext> {
  assert(
      node.mmio_base != 0 &&
      "mmio_helper::Prepare: node has no MMIO base; driver matched wrong node");
 
  size_t size = node.mmio_size > 0 ? node.mmio_size : default_size;
  auto map_result =
      VirtualMemorySingleton::instance().MapMMIO(node.mmio_base, size);
  if (!map_result.has_value()) {
    return std::unexpected(map_result.error());
  }
 
  return ProbeContext{node.mmio_base, size};
}
 
}  // namespace mmio_helper