system_tables.h

Go to the documentation of this file.

#pragma once
 
#include "di/container/string/prelude.h"
#include "di/util/prelude.h"
#include "di/vocab/array/prelude.h"
#include "di/vocab/span/prelude.h"
 
namespace iris::acpi {
auto validate_acpi_checksum(di::Span<byte const> data) -> bool;

struct [[gnu::packed]] RSDP {
    di::Array<byte, 8> signature;
    u8 checksum;
    di::Array<byte, 6> oem_id;
    u8 revision;
    u32 rsdt_address;

    u32 length;
    u64 xsdt_address;
    u8 extended_checksum;
    di::Array<byte, 3> reserved;
 
    auto validate_v1() const -> bool {
        return validate_acpi_checksum(di::as_bytes(di::Span { this, 1 }) | di::take(20));
    }
};

struct [[gnu::packed]] SDTHeader {
    di::Array<byte, 4> signature;
    u32 length;
    u8 revision;
    u8 checksum;
    di::Array<byte, 6> oem_id;
    di::Array<byte, 8> oem_table_id;
    u32 oem_revision;
    u32 creator_id;
    u32 creator_revision;
 
    auto as_bytes() const -> di::Span<byte const> {
        return di::Span { reinterpret_cast<byte const*>(this), this->length };
    }
 
    auto validate(usize min_length) const -> bool {
        if (this->length < min_length) {
            return false;
        }
        return validate_acpi_checksum(this->as_bytes());
    }
};

struct [[gnu::packed]] RSDT : SDTHeader {
    auto entries() const -> di::Span<u32 const> {
        return di::Span { reinterpret_cast<u32 const*>(this + 1), (this->length - sizeof(SDTHeader)) / sizeof(u32) };
    }
};

enum class InterruptControllerStructureType : u8 {
    LocalApic = 0x0,
    IoApic = 0x1,
    InterruptSourceOverride = 0x2,
    NmiSource = 0x3,
    LocalApicNmi = 0x4,
    LocalApicAddressOverride = 0x5,
    IoSapic = 0x6,
    LocalSapic = 0x7,
    PlatformInterruptSources = 0x8,
    LocalX2Apic = 0x9,
    LocalX2ApicNmi = 0xA,
    GicCpuInterface = 0xB,
    GicDistrutor = 0xC,
    GicMsiFrame = 0xD,
    GicRedistributor = 0xE,
    GIGInterruptTranslationService = 0xF,
    MultiprocessorWakeup = 0x10,
    CorePic = 0x11,
    LegacyPic = 0x12,
    HyperTransportPic = 0x13,
    ExtendIoPic = 0x14,
    MsiPic = 0x15,
    BridgeIoPic = 0x16,
    LowPinCountPic = 0x17,
};

struct InterruptControllerStructureHeader {
    InterruptControllerStructureType type;
    u8 length;
 
    auto next() const -> InterruptControllerStructureHeader const* {
        return reinterpret_cast<InterruptControllerStructureHeader const*>(reinterpret_cast<byte const*>(this) +
                                                                           this->length);
    }
 
    auto validate(usize min_length) const -> bool { return this->length >= min_length; }
};

struct [[gnu::packed]] ProcessorLocalApicStructure : InterruptControllerStructureHeader {
    enum class Flags : u32 {
        Enabled = 1,
        OnlineCapable = 2,
    };
 
    u8 processor_id;
    u8 apic_id;
    Flags flags;
};

struct [[gnu::packed]] IoApicStructure : InterruptControllerStructureHeader {
    u8 io_apic_id;
    u8 reserved;
    u32 io_apic_address;
    u32 global_system_interrupt_base;
};

struct [[gnu::packed]] MPSInterruptFlags {
    enum class Polarity {
        BusDefined = 0,
        ActiveHigh = 1,
        Reserved = 2,
        ActiveLow = 3,
    };
 
    enum class TriggerMode {
        BusDefined = 0,
        Edge = 1,
        Reserved = 2,
        Level = 3,
    };
 
    auto polarity() const -> Polarity { return Polarity(value & 0b11); }
    auto trigger_mode() const -> TriggerMode { return TriggerMode((value & 0b1100) >> 2); }
 
    u16 value;
};

struct [[gnu::packed]] InterruptSourceOverrideStructure : InterruptControllerStructureHeader {
    u8 bus;
    u8 source;
    u32 global_system_interrupt;
    MPSInterruptFlags flags;
};

struct [[gnu::packed]] LocalApicNmiStructure : InterruptControllerStructureHeader {
    u8 apic_processor_uid;
    MPSInterruptFlags flags;
    u8 local_apic_lint;
};
 
class InterruptControllerStructureIterator
    : public di::container::IteratorBase<InterruptControllerStructureIterator, di::ForwardIteratorTag,
                                         InterruptControllerStructureHeader, isize> {
public:
    InterruptControllerStructureIterator() = default;
 
    explicit InterruptControllerStructureIterator(InterruptControllerStructureHeader const* current,
                                                  InterruptControllerStructureHeader const* end)
        : m_current(current), m_end(end) {}
 
    auto operator*() const -> InterruptControllerStructureHeader const& { return *m_current; }
    auto operator->() const -> InterruptControllerStructureHeader const* { return m_current; }
 
    auto validate(usize min_size) const -> bool {
        auto const* readable_end = reinterpret_cast<byte const*>(m_current) + min_size;
        return m_current->validate(min_size) && m_current->next() <= m_end &&
               di::to_uintptr(readable_end) <= di::to_uintptr(m_end);
    }
 
    void advance_one() { m_current = m_current->next(); }
 
    auto begin() const -> InterruptControllerStructureIterator { return *this; }
    auto end() const -> InterruptControllerStructureIterator {
        return InterruptControllerStructureIterator { m_end, m_end };
    }
 
private:
    friend auto operator==(InterruptControllerStructureIterator const& a, InterruptControllerStructureIterator const& b)
        -> bool {
        return a.m_current == b.m_current;
    }
 
    InterruptControllerStructureHeader const* m_current { nullptr };
    InterruptControllerStructureHeader const* m_end { nullptr };
};

struct [[gnu::packed]] MADT : SDTHeader {
    enum class Flags : u32 {
        PcAtCompatible = 1,
    };
 
    u32 local_apic_address;
    Flags flags;
 
    auto interrupt_controller_structures() const -> InterruptControllerStructureIterator {
        return InterruptControllerStructureIterator {
            reinterpret_cast<InterruptControllerStructureHeader const*>(this + 1),
            reinterpret_cast<InterruptControllerStructureHeader const*>(this->as_bytes().end())
        };
    }
};
 
template<usize N>
constexpr auto byte_array_to_string_view(di::Array<byte, N> const& array) {
    return di::TransparentStringView { reinterpret_cast<char const*>(array.data()), array.size() };
}
}