kapi: add device resources

2 files changed, 444 insertions, 0 deletions

diff --git a/kernel/kapi/devices/device.cpp b/kernel/kapi/devices/device.cpp
index 9c2d8d40..a05a1653 100644
--- a/kernel/kapi/devices/device.cpp
+++ b/kernel/kapi/devices/device.cpp
@@ -2,10 +2,18 @@
 
 #include <kapi/devices.hpp>
 #include <kapi/devices/bus.hpp>
+#include <kapi/devices/resource.hpp>
 
 #include <kstd/memory.hpp>
 #include <kstd/mutex.hpp>
+#include <kstd/result.hpp>
 #include <kstd/string.hpp>
+#include <kstd/system_error.hpp>
+#include <kstd/vector.hpp>
+
+#include <algorithm>
+#include <cstddef>
+#include <ranges>
 
 namespace kapi::devices
 {
@@ -75,6 +83,36 @@ namespace kapi::devices
     m_driver_data = data;
   }
 
+  auto device::resources() const -> kstd::vector<resource>
+  {
+    auto guard = kstd::lock_guard{m_lock};
+    return m_resources;
+  }
+
+  auto device::request_resource(resource_type type, std::size_t index) const -> kstd::result<resource>
+  {
+    auto guard = kstd::lock_guard{m_lock};
+
+    auto numbered_resources = std::views::enumerate(m_resources);
+    auto found = std::ranges::find_if(numbered_resources, [&](auto entry) {
+      auto const & [number, resource] = entry;
+      return resource.type == type && static_cast<std::size_t>(number) == index;
+    });
+
+    if (found != numbered_resources.end())
+    {
+      return kstd::success(*found.base());
+    }
+
+    return kstd::failure(make_error_code(kstd::errc::invalid_argument));
+  }
+
+  auto device::set_resources(kstd::vector<resource> resources) -> void
+  {
+    auto guard = kstd::lock_guard{m_lock};
+    m_resources = resources;
+  }
+
   auto device::query_facet(kapi::capabilities::facet_id) -> void *
   {
     return nullptr;
diff --git a/kernel/kapi/devices/device.tests.cpp b/kernel/kapi/devices/device.tests.cpp
new file mode 100644
index 00000000..8104f6eb
--- /dev/null
+++ b/kernel/kapi/devices/device.tests.cpp
@@ -0,0 +1,406 @@
+#include <kapi/devices/device.hpp>
+
+#include <kapi/devices/resource.hpp>
+
+#include <kstd/memory.hpp>
+#include <kstd/system_error.hpp>
+#include <kstd/units.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("Devices allow access to their resources", "[kapi][devices]")
+{
+  GIVEN("A device without any resources")
+  {
+    auto device = kstd::make_shared<kapi::devices::device>("test_device");
+
+    THEN("its resources vector is empty")
+    {
+      REQUIRE(device->resources().empty());
+    }
+
+    WHEN("trying to get the first MMIO resource via the type-safe accessor")
+    {
+      auto result = device->request_resource<kapi::devices::resource_type::mmio>(0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first MMIO resource via the unsafe accessor")
+    {
+      auto result = device->request_resource(kapi::devices::resource_type::mmio, 0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first I/O port resource via the type-safe accessor")
+    {
+      auto result = device->request_resource<kapi::devices::resource_type::port>(0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first I/O port resource via the unsafe accessor")
+    {
+      auto result = device->request_resource(kapi::devices::resource_type::port, 0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first IRQ resource via the type-safe accessor")
+    {
+      auto result = device->request_resource<kapi::devices::resource_type::irq>(0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first IRQ resource via the unsafe accessor")
+    {
+      auto result = device->request_resource(kapi::devices::resource_type::irq, 0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first DMA resource via the type-safe accessor")
+    {
+      auto result = device->request_resource<kapi::devices::resource_type::dma>(0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("trying to get the first DMA resource via the unsafe accessor")
+    {
+      auto result = device->request_resource(kapi::devices::resource_type::dma, 0);
+
+      THEN("the result is an error")
+      {
+        REQUIRE_FALSE(result);
+      }
+
+      THEN("the error is 'invalid argument'")
+      {
+        REQUIRE(result.error() == kstd::errc::invalid_argument);
+      }
+    }
+
+    WHEN("adding an MMIO resource")
+    {
+      auto range = kapi::devices::mmio_range{{}, kstd::units::bytes{100}};
+      device->set_resources({kapi::devices::resource{range}});
+
+      AND_WHEN("trying to get the first MMIO resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::mmio>();
+
+        THEN("the result is a success")
+        {
+          REQUIRE(result);
+        }
+
+        THEN("the result is the expected MMIO range")
+        {
+          REQUIRE(result == range);
+        }
+      }
+
+      AND_WHEN("trying to get the first I/O port resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::port>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first IRQ resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::irq>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first DMA resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::dma>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+    }
+
+    WHEN("adding an I/O port resource")
+    {
+      auto port = kapi::devices::io_port{0x40, 1};
+      device->set_resources({kapi::devices::resource{port}});
+
+      AND_WHEN("trying to get the first MMIO resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::mmio>();
+
+        THEN("the result is en error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first I/O port resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::port>();
+
+        THEN("the result is a success")
+        {
+          REQUIRE(result);
+        }
+
+        THEN("the result is the expected MMIO range")
+        {
+          REQUIRE(result == port);
+        }
+      }
+
+      AND_WHEN("trying to get the first IRQ resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::irq>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first DMA resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::dma>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+    }
+
+    WHEN("adding an interrupt line resource")
+    {
+      auto line = kapi::devices::interrupt_line{128};
+      device->set_resources({kapi::devices::resource{line}});
+
+      AND_WHEN("trying to get the first MMIO resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::mmio>();
+
+        THEN("the result is en error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first I/O port resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::port>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first IRQ resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::irq>(0);
+
+        THEN("the result is a success")
+        {
+          REQUIRE(result);
+        }
+
+        THEN("the result is the expected interrupt line")
+        {
+          REQUIRE(result == line);
+        }
+      }
+
+      AND_WHEN("trying to get the first DMA resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::dma>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+    }
+
+    WHEN("adding a DMA channel resource")
+    {
+      auto channel = kapi::devices::dma_channel{1024};
+      device->set_resources({kapi::devices::resource{channel}});
+
+      AND_WHEN("trying to get the first MMIO resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::mmio>();
+
+        THEN("the result is en error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first I/O port resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::port>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first IRQ resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::irq>(0);
+
+        THEN("the result is an error")
+        {
+          REQUIRE_FALSE(result);
+        }
+
+        THEN("the error is 'invalid argument'")
+        {
+          REQUIRE(result.error() == kstd::errc::invalid_argument);
+        }
+      }
+
+      AND_WHEN("trying to get the first DMA resource via the type-safe accessor")
+      {
+        auto result = device->request_resource<kapi::devices::resource_type::dma>(0);
+
+        THEN("the result is a success")
+        {
+          REQUIRE(result);
+        }
+
+        THEN("the result it the expected DMA channel")
+        {
+          REQUIRE(result == channel);
+        }
+      }
+    }
+  }
+}