serenity/Kernel/Firmware/ACPI/Parser.cpp

/*
 * Copyright (c) 2020-2021, Liav A. <[email protected]>
 * Copyright (c) 2020-2021, Andreas Kling <[email protected]>
 * Copyright (c) 2022, the SerenityOS developers.
 * Copyright (c) 2026, Undefine <[email protected]>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/Format.h>
#include <AK/Platform.h>
#include <AK/ScopeGuard.h>
#include <AK/StdLibExtras.h>
#include <AK/StringView.h>
#include <AK/Try.h>
#include <Kernel/Debug.h>
#include <Kernel/Firmware/ACPI/GenericAddress.h>
#include <Kernel/Firmware/ACPI/Parser.h>
#include <Kernel/Interrupts/InterruptDisabler.h>
#include <Kernel/Library/StdLib.h>
#include <Kernel/Memory/TypedMapping.h>
#include <Kernel/Sections.h>
#include <LibACPI/Definitions.h>
#include <LibACPI/Table.h>

namespace Kernel::ACPI {

static Parser* s_acpi_parser;

Parser* Parser::the()
{
    return s_acpi_parser;
}

ErrorOr<void> Parser::initialize(PhysicalAddress rsdp)
{
    VERIFY(!s_acpi_parser);

    ArmedScopeGuard guard = [] {
        // Make sure ACPI::is_enabled returns false.
        delete s_acpi_parser;
        s_acpi_parser = nullptr;
    };

    s_acpi_parser = new (nothrow) Parser(rsdp);
    if (!s_acpi_parser)
        return ENOMEM;

    TRY(s_acpi_parser->locate_main_system_description_table());
    TRY(s_acpi_parser->initialize_main_system_description_table());

    guard.disarm();
    return {};
}

void Parser::enumerate_static_tables(Function<void(StringView, PhysicalAddress, size_t)> callback)
{
    for (auto& p_table : m_sdt_pointers) {
        auto table = Memory::map_typed<::ACPI::Structures::SDTHeader>(p_table).release_value_but_fixme_should_propagate_errors();
        callback({ table->sig, 4 }, p_table, table->length);
    }
}

UNMAP_AFTER_INIT ErrorOr<void> Parser::full_initialize()
{
    TRY(process_fadt_data());
    TRY(process_dsdt());

    return {};
}

UNMAP_AFTER_INIT Optional<PhysicalAddress> Parser::find_table(StringView signature)
{
    dbgln_if(ACPI_DEBUG, "ACPI: Calling Find Table method!");
    for (auto p_sdt : m_sdt_pointers) {
        auto sdt_or_error = Memory::map_typed<::ACPI::Structures::SDTHeader>(p_sdt);
        if (sdt_or_error.is_error()) {
            dbgln_if(ACPI_DEBUG, "ACPI: Failed mapping Table @ {}", p_sdt);
            continue;
        }
        dbgln_if(ACPI_DEBUG, "ACPI: Examining Table @ {}", p_sdt);
        if (!strncmp(sdt_or_error.value()->sig, signature.characters_without_null_termination(), 4)) {
            dbgln_if(ACPI_DEBUG, "ACPI: Found Table @ {}", p_sdt);
            return p_sdt;
        }
    }
    return {};
}

bool Parser::handle_interrupt()
{
    TODO();
}

UNMAP_AFTER_INIT ErrorOr<void> Parser::process_fadt_data()
{
    dmesgln("ACPI: Initializing Fixed ACPI data");

    auto maybe_fadt = find_table("FACP"sv);
    if (!maybe_fadt.has_value() || maybe_fadt->is_null()) {
        dbgln("ACPI: Failed to find the FADT table");
        return ENOENT;
    }
    m_fadt = maybe_fadt.release_value();

    dbgln_if(ACPI_DEBUG, "ACPI: FADT @ {}", m_fadt);

    auto sdt = TRY(Memory::map_typed<::ACPI::Structures::FADT>(m_fadt));
    dmesgln("ACPI: Fixed ACPI data, Revision {}, length: {} bytes", static_cast<size_t>(sdt->h.revision), static_cast<size_t>(sdt->h.length));
    m_x86_specific_flags.cmos_rtc_not_present = has_flag(sdt->ia_pc_boot_arch_flags, ::ACPI::FADTFlags::IA_PC_Flags::CMOS_RTC_Not_Present);

    // FIXME: QEMU doesn't report that we have an i8042 controller in these flags, even if it should (when FADT revision is 3),
    // Later on, we need to make sure that we enumerate the ACPI namespace (AML encoded), instead of just using this value.
    m_x86_specific_flags.keyboard_8042 = (sdt->h.revision <= 3) || has_flag(sdt->ia_pc_boot_arch_flags, ::ACPI::FADTFlags::IA_PC_Flags::PS2_8042);

    m_x86_specific_flags.legacy_devices = has_flag(sdt->ia_pc_boot_arch_flags, ::ACPI::FADTFlags::IA_PC_Flags::Legacy_Devices);
    m_x86_specific_flags.msi_not_supported = has_flag(sdt->ia_pc_boot_arch_flags, ::ACPI::FADTFlags::IA_PC_Flags::MSI_Not_Supported);
    m_x86_specific_flags.vga_not_present = has_flag(sdt->ia_pc_boot_arch_flags, ::ACPI::FADTFlags::IA_PC_Flags::VGA_Not_Present);

    m_hardware_flags.cpu_software_sleep = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::CPU_SW_SLP);
    m_hardware_flags.docking_capability = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::DCK_CAP);
    m_hardware_flags.fix_rtc = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::FIX_RTC);
    m_hardware_flags.force_apic_cluster_model = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::FORCE_APIC_CLUSTER_MODEL);
    m_hardware_flags.force_apic_physical_destination_mode = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::FORCE_APIC_PHYSICAL_DESTINATION_MODE);
    m_hardware_flags.hardware_reduced_acpi = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::HW_REDUCED_ACPI);
    m_hardware_flags.headless = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::HEADLESS);
    m_hardware_flags.low_power_s0_idle_capable = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::LOW_POWER_S0_IDLE_CAPABLE);
    m_hardware_flags.multiprocessor_c2 = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::P_LVL2_UP);
    m_hardware_flags.pci_express_wake = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::PCI_EXP_WAK);
    m_hardware_flags.power_button = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::PWR_BUTTON);
    m_hardware_flags.processor_c1 = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::PROC_C1);
    m_hardware_flags.remote_power_on_capable = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::REMOTE_POWER_ON_CAPABLE);
    m_hardware_flags.reset_register_supported = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::RESET_REG_SUPPORTED);
    m_hardware_flags.rtc_s4 = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::RTC_s4);
    m_hardware_flags.s4_rtc_status_valid = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::S4_RTC_STS_VALID);
    m_hardware_flags.sealed_case = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::SEALED_CASE);
    m_hardware_flags.sleep_button = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::SLP_BUTTON);
    m_hardware_flags.timer_value_extension = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::TMR_VAL_EXT);
    m_hardware_flags.use_platform_clock = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::USE_PLATFORM_CLOCK);
    m_hardware_flags.wbinvd = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::WBINVD);
    m_hardware_flags.wbinvd_flush = has_flag(sdt->flags, ::ACPI::FADTFlags::FeatureFlags::WBINVD_FLUSH);

    m_interrupt_handler = TRY(InterruptHandler::create(*this, sdt->sci_int));

    return {};
}

UNMAP_AFTER_INIT ErrorOr<void> Parser::process_dsdt()
{
    auto sdt = TRY(Memory::map_typed<::ACPI::Structures::FADT>(m_fadt));

    // Add DSDT-pointer to expose the full table in /sys/firmware/acpi/
    TRY(m_sdt_pointers.try_append(PhysicalAddress(sdt->dsdt_ptr)));

    if (kernel_command_line().acpi_feature_level() == AcpiFeatureLevel::Enabled) {
        m_aml_interpreter = TRY(::ACPI::AML::Interpreter::create());
        ArmedScopeGuard guard = [&]() {
            // Ensure the AML interpreter is cleaned up if an error occurs.
            m_aml_interpreter = nullptr;
        };

        auto dsdt = TRY(Memory::map_typed<::ACPI::Structures::DSDT>(PhysicalAddress(sdt->dsdt_ptr)));
        dsdt = TRY(Memory::map_typed<::ACPI::Structures::DSDT>(PhysicalAddress(sdt->dsdt_ptr), dsdt->h.length));

        dmesgln("ACPI: Using DSDT @ {} with {} bytes", PhysicalAddress(sdt->dsdt_ptr), dsdt->h.length);

        TRY(m_aml_interpreter->load(ReadonlyBytes { dsdt.ptr(), dsdt->h.length }));
        guard.disarm();
    }

    return {};
}

bool Parser::can_reboot()
{
    auto fadt_or_error = Memory::map_typed<::ACPI::Structures::FADT>(m_fadt);
    if (fadt_or_error.is_error())
        return false;
    if (fadt_or_error.value()->h.revision < 2)
        return false;
    return m_hardware_flags.reset_register_supported;
}

bool Parser::validate_reset_register(Memory::TypedMapping<::ACPI::Structures::FADT> const& fadt)
{
    // According to https://uefi.org/specs/ACPI/6.5/04_ACPI_Hardware_Specification.html#reset-register,
    // the reset register can only be located in I/O bus, PCI bus or memory-mapped.
    return (fadt->reset_reg.address_space == ::ACPI::GenericAddressStructure::AddressSpace::PCIConfigurationSpace || fadt->reset_reg.address_space == ::ACPI::GenericAddressStructure::AddressSpace::SystemMemory || fadt->reset_reg.address_space == ::ACPI::GenericAddressStructure::AddressSpace::SystemIO);
}

void Parser::try_acpi_reboot()
{
    InterruptDisabler disabler;
    if (!can_reboot()) {
        dmesgln("ACPI: Reboot not supported!");
        return;
    }
    dbgln_if(ACPI_DEBUG, "ACPI: Rebooting, probing FADT ({})", m_fadt);

    auto fadt_or_error = Memory::map_typed<::ACPI::Structures::FADT>(m_fadt);
    if (fadt_or_error.is_error()) {
        dmesgln("ACPI: Failed probing FADT {}", fadt_or_error.error());
        return;
    }
    auto fadt = fadt_or_error.release_value();

    VERIFY(validate_reset_register(fadt));
    if (auto maybe_error = write_generic_address(fadt->reset_reg, fadt->reset_value); maybe_error.is_error()) {
        dmesgln("ACPI: Failed to write FADT reset register: {}", maybe_error.release_error());
        return;
    }

    Processor::halt();
}

// https://uefi.org/specs/ACPI/6.6/16_Waking_and_Sleeping.html#transitioning-from-the-working-to-the-soft-off-state
ErrorOr<void> Parser::try_acpi_shutdown()
{
    if (!m_aml_interpreter) {
        dmesgln("ACPI: AML interpreter not available");
        return Error::from_errno(ENOTSUP);
    }

    auto fadt = TRY(Memory::map_typed<::ACPI::Structures::FADT>(m_fadt));

    // NOTE: We need to check the length, because older ACPI revision might not have those fields
    auto pm1a_control = TRY(get_pm1a_control());
    auto pm1b_control = TRY(get_pm1b_control());
    bool sleep_control_available = fadt->h.length >= offsetof(::ACPI::Structures::FADT, sleep_control) + sizeof(fadt->sleep_control) && !fadt->sleep_control.is_null();

    auto s5_values = TRY(extract_s5_values());

    // FIXME: 1. OSPM executes the _PTS control method, passing the argument 5.

    // 2. OSPM prepares its components to shut down (flushing disk caches).
    // NOTE: This step is done ahead of this function call

    // 3. If not a HW-reduced ACPI platform, OSPM writes SLP_TYPa (from the \_S5 object) with the SLP_ENa bit set to the PM1a_CNT register.
    if (!m_hardware_flags.hardware_reduced_acpi) {
        if (!pm1a_control.has_value()) {
            dmesgln("ACPI: PM1a control register not available");
            return Error::from_errno(ENOTSUP);
        }

        ::ACPI::Structures::PM1ControlRegister shutdown_value = bit_cast<::ACPI::Structures::PM1ControlRegister>(static_cast<u16>(TRY(read_generic_address(*pm1a_control))));
        shutdown_value.SLP_EN = true;
        shutdown_value.SLP_TYPx = s5_values.SLP_TYPa;

        TRY(write_generic_address(*pm1a_control, bit_cast<u16>(shutdown_value)));
    }

    // 4. OSPM writes SLP_TYPb (from the \_S5 object) with the SLP_ENb bit set to the PM1b_CNT register, or writes the HW-reduced ACPI Sleep
    //    Type value for S5 and the SLP_EN bit to the Sleep Control Register.
    if (m_hardware_flags.hardware_reduced_acpi) {
        if (!sleep_control_available) {
            dmesgln("ACPI: Sleep control register not available");
            return Error::from_errno(ENOTSUP);
        }

        auto shutdown_value = bit_cast<::ACPI::Structures::SleepControlRegister>(static_cast<u8>(TRY(read_generic_address(fadt->sleep_control))));
        shutdown_value.SLP_EN = true;
        shutdown_value.SLP_TYPx = s5_values.SLP_TYPa;

        TRY(write_generic_address(fadt->sleep_control, bit_cast<u8>(shutdown_value)));
    } else if (pm1b_control.has_value()) {
        // PM1b control register is optional, and doesn't need to be present for the system to support S5 sleep state.
        auto shutdown_value = bit_cast<::ACPI::Structures::PM1ControlRegister>(static_cast<u16>(TRY(read_generic_address(*pm1b_control))));
        shutdown_value.SLP_EN = true;
        shutdown_value.SLP_TYPx = s5_values.SLP_TYPb;

        TRY(write_generic_address(*pm1b_control, bit_cast<u16>(shutdown_value)));
    }

    // 5. The system enters the Soft Off state.
    Processor::halt();
}

ErrorOr<Parser::S5Values> Parser::extract_s5_values()
{
    auto s5_node = TRY(m_aml_interpreter->evaluate("\\_S5_"sv));
    auto s5_package = TRY(s5_node.release_as<::ACPI::AML::Package>());
    if (s5_package.package().size() < 2)
        return Error::from_errno(EINVAL);

    u16 SLP_TYPa = TRY(s5_package.package()[0].as<u64>());
    u16 SLP_TYPb = TRY(s5_package.package()[1].as<u64>());

    return Parser::S5Values { SLP_TYPa, SLP_TYPb };
}

ErrorOr<Optional<::ACPI::Structures::GenericAddressStructure>> Parser::get_pm1a_control()
{
    auto fadt = TRY(Memory::map_typed<::ACPI::Structures::FADT>(m_fadt));

    if (fadt->h.length >= offsetof(::ACPI::Structures::FADT, x_pm1a_cnt_blk) + sizeof(fadt->x_pm1a_cnt_blk) && !fadt->x_pm1a_cnt_blk.is_null())
        return fadt->x_pm1a_cnt_blk;

#if ARCH(X86_64)
    if (fadt->PM1a_CNT_BLK != 0)
        return make_generic_address_from_io_port(fadt->PM1a_CNT_BLK);
#endif

    return OptionalNone {};
}

ErrorOr<Optional<::ACPI::Structures::GenericAddressStructure>> Parser::get_pm1b_control()
{
    auto fadt = TRY(Memory::map_typed<::ACPI::Structures::FADT>(m_fadt));

    if (fadt->h.length >= offsetof(::ACPI::Structures::FADT, x_pm1b_cnt_blk) + sizeof(fadt->x_pm1b_cnt_blk) && !fadt->x_pm1b_cnt_blk.is_null())
        return fadt->x_pm1b_cnt_blk;

#if ARCH(X86_64)
    if (fadt->PM1b_CNT_BLK != 0)
        return make_generic_address_from_io_port(fadt->PM1b_CNT_BLK);
#endif

    return OptionalNone {};
}

ErrorOr<size_t> Parser::get_table_size(PhysicalAddress table_header)
{
    InterruptDisabler disabler;
    dbgln_if(ACPI_DEBUG, "ACPI: Checking SDT Length");
    auto mapped = TRY(Memory::map_typed<::ACPI::Structures::SDTHeader>(table_header));
    auto length = mapped->length;
    return length;
}

UNMAP_AFTER_INIT ErrorOr<void> Parser::initialize_main_system_description_table()
{
    dbgln_if(ACPI_DEBUG, "ACPI: Checking Main SDT Length to choose the correct mapping size");
    VERIFY(!m_main_system_description_table.is_null());
    auto length = TRY(get_table_size(m_main_system_description_table));

    auto sdt = TRY(Memory::map_typed<::ACPI::Structures::SDTHeader>(m_main_system_description_table, length));

    dmesgln("ACPI: Main Description Table valid? {}", ::ACPI::validate_table(*sdt));

    if (m_xsdt_supported) {
        auto const* xsdt = reinterpret_cast<::ACPI::Structures::XSDT const*>(sdt.ptr());
        dmesgln("ACPI: Using XSDT, enumerating tables @ {}", m_main_system_description_table);
        dmesgln("ACPI: XSDT revision {}, total length: {}", sdt->revision, length);
        dbgln_if(ACPI_DEBUG, "ACPI: XSDT pointer @ {}", VirtualAddress { xsdt });
        for (u32 i = 0; i < ((length - sizeof(::ACPI::Structures::SDTHeader)) / sizeof(u64)); i++) {
            dbgln_if(ACPI_DEBUG, "ACPI: Found new table [{0}], @ V{1:p} - P{1:p}", i, &xsdt->table_ptrs[i]);
            TRY(m_sdt_pointers.try_append(PhysicalAddress(xsdt->table_ptrs[i])));
        }
    } else {
        auto const* rsdt = reinterpret_cast<::ACPI::Structures::RSDT const*>(sdt.ptr());
        dmesgln("ACPI: Using RSDT, enumerating tables @ {}", m_main_system_description_table);
        dmesgln("ACPI: RSDT revision {}, total length: {}", sdt->revision, length);
        dbgln_if(ACPI_DEBUG, "ACPI: RSDT pointer @ {}", VirtualAddress { rsdt });
        for (u32 i = 0; i < ((length - sizeof(::ACPI::Structures::SDTHeader)) / sizeof(u32)); i++) {
            dbgln_if(ACPI_DEBUG, "ACPI: Found new table [{0}], @ V{1:p} - P{1:p}", i, &rsdt->table_ptrs[i]);
            TRY(m_sdt_pointers.try_append(PhysicalAddress(rsdt->table_ptrs[i])));
        }
    }

    return {};
}

UNMAP_AFTER_INIT ErrorOr<void> Parser::locate_main_system_description_table()
{
    auto rsdp = TRY(Memory::map_typed<::ACPI::Structures::RSDPDescriptor20>(m_rsdp));

    if (rsdp->base.revision == 0) {
        m_xsdt_supported = false;
    } else if (rsdp->base.revision >= 2) {
        m_xsdt_supported = rsdp->xsdt_ptr != 0;
    }

    if (!m_xsdt_supported) {
        m_main_system_description_table = PhysicalAddress(rsdp->base.rsdt_ptr);
    } else {
        m_main_system_description_table = PhysicalAddress(rsdp->xsdt_ptr);
    }

    return {};
}

UNMAP_AFTER_INIT Parser::Parser(PhysicalAddress rsdp)
    : m_rsdp(rsdp)
{
    dmesgln("ACPI: Using RSDP @ {}", rsdp);
}

}