Luna/kernel/src/acpi/RSDT.cpp

#define MODULE "acpi"

#include "acpi/RSDT.h"
#include "bootboot.h"
#include "log/Log.h"
#include "memory/MemoryManager.h"
#include "std/stdio.h"
#include "std/string.h"

extern BOOTBOOT bootboot;

ACPI::SDTHeader* ACPI::get_rsdt_or_xsdt()
{
    static void* cache = nullptr;
    if (cache) return (SDTHeader*)cache;
    kdbgln("First time accessing the RSDT/XSDT, mapping it into memory");
    void* physical = (void*)bootboot.arch.x86_64.acpi_ptr;
    uint64_t offset = (uint64_t)physical % 4096;
    kdbgln("RSDT/XSDT physical address: %lx", (uint64_t)physical);
    cache = MemoryManager::get_unaligned_mapping(physical);
    uint64_t numPages = 1;
    while ((offset + ((SDTHeader*)cache)->Length) > (numPages * 4096))
    {
        kwarnln("RSDT/XSDT extends beyond the mapped page, mapping one more page");
        MemoryManager::release_unaligned_mappings(cache, numPages);
        numPages++;
        cache = MemoryManager::get_unaligned_mappings(cache, numPages);
    }
    kdbgln("Mapped RSDT/XSDT to virtual address %lx, uses %ld pages", (uint64_t)cache, numPages);
    SDTHeader* result = (SDTHeader*)cache;
    return result;
}

bool ACPI::validate_rsdt_or_xsdt(ACPI::SDTHeader* root_sdt)
{
    if (!validate_sdt_header(root_sdt)) return false;
    if (strncmp(root_sdt->Signature, "XSDT", 4) == 0) return true;
    if (strncmp(root_sdt->Signature, "RSDT", 4) == 0) return true;
    return false;
}

bool ACPI::is_xsdt()
{
    static bool cached = false;
    static bool cache = false;
    if (cached) return cache;
    SDTHeader* rootSDT = get_rsdt_or_xsdt();
    cache = (strncmp(rootSDT->Signature, "XSDT", 4) == 0);
    cached = true;
    return cache;
}

void* ACPI::find_table(ACPI::SDTHeader* root_sdt, const char* signature)
{
    bool isXSDT = is_xsdt();
    uint64_t entries = (root_sdt->Length - sizeof(SDTHeader)) / (isXSDT ? 8 : 4);
    kdbgln("Searching for table %s in the %s at %lx (table contains %ld entries)", signature, isXSDT ? "XSDT" : "RSDT",
           (uint64_t)root_sdt, entries);

    for (uint64_t i = 0; i < entries; i++)
    {
        kdbgln("Testing for table %s in entry %ld", signature, i);
        SDTHeader* h;
        if (isXSDT)
        {
            uint64_t reversedAddress = (uint64_t)((XSDT*)root_sdt)->other_sdt[i];
            uint64_t correctAddress = reversedAddress >> 32 | reversedAddress << 32;
            h = (SDTHeader*)correctAddress;
        }
        else
        {
            uint32_t entry = ((RSDT*)root_sdt)->other_sdt[i];
            h = (SDTHeader*)(uint64_t)entry;
        }
        if (!h)
        {
            kwarnln("Entry %ld in the %s points to null", i, isXSDT ? "XSDT" : "RSDT");
            continue;
        }
        kdbgln("Physical address of entry: %lx", (uint64_t)h);
        SDTHeader* realHeader = (SDTHeader*)MemoryManager::get_unaligned_mapping(h);
        kdbgln("Mapped entry to virtual address %lx", (uint64_t)realHeader);
        if (!validate_sdt_header(realHeader))
        {
            kwarnln("Header of entry %ld is not valid, skipping this entry", i);
            MemoryManager::release_unaligned_mapping(realHeader);
            continue;
        }
        char tableSignature[5];
        memcpy(tableSignature, h->Signature, 4);
        tableSignature[4] = 0;
        kdbgln("Comparing target signature (%s) to signature of entry (%s)", signature, tableSignature);
        if (strncmp(h->Signature, signature, 4) == 0)
        {
            kdbgln("Found table %s", signature);
            return (void*)realHeader;
        }
        kdbgln("Signatures do not match, unmapping entry and continuing");
        MemoryManager::release_unaligned_mapping(realHeader);
    }

    return NULL;
}