aboutsummaryrefslogtreecommitdiff
path: root/kernel
diff options
context:
space:
mode:
Diffstat (limited to 'kernel')
-rw-r--r--kernel/kapi/devices/device.cpp38
-rw-r--r--kernel/kapi/devices/device.tests.cpp406
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);
+ }
+ }
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-07-31 03:32:59 +0000