kernel: acpi: Add uACPI portexpt

See https://github.com/uACPI/uACPI/

Signed-off-by: Ian Moffett <ian@osmora.org>

1 files changed, 1399 insertions, 0 deletions

diff --git a/sys/dev/acpi/uacpi/tables.c b/sys/dev/acpi/uacpi/tables.c
new file mode 100644
index 0000000..df7d7b9
--- /dev/null
+++ b/sys/dev/acpi/uacpi/tables.c
@@ -0,0 +1,1399 @@
+#include <uacpi/internal/tables.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/mutex.h>
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(
+    table_array, struct uacpi_installed_table, UACPI_STATIC_TABLE_ARRAY_LEN
+)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+    table_array, struct uacpi_installed_table, static
+)
+
+static struct table_array tables;
+static uacpi_bool early_table_access;
+static uacpi_table_installation_handler installation_handler;
+
+#ifndef UACPI_BAREBONES_MODE
+
+static uacpi_handle table_mutex;
+
+#define ENSURE_TABLES_ONLINE()                         \
+    do {                                               \
+        if (!early_table_access)                       \
+            UACPI_ENSURE_INIT_LEVEL_AT_LEAST(          \
+                UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED \
+            );                                         \
+    } while (0)
+
+#else
+
+/*
+ * Use a dummy function instead of a macro to prevent the following error:
+ *     error: statement with no effect [-Werror=unused-value]
+ */
+static inline uacpi_status dummy_mutex_acquire_release(uacpi_handle mtx)
+{
+    UACPI_UNUSED(mtx);
+    return UACPI_STATUS_OK;
+}
+
+#define table_mutex UACPI_NULL
+#define uacpi_acquire_native_mutex_may_be_null dummy_mutex_acquire_release
+#define uacpi_release_native_mutex_may_be_null dummy_mutex_acquire_release
+
+#define ENSURE_TABLES_ONLINE()                       \
+    do {                                             \
+        if (!early_table_access)                     \
+            return UACPI_STATUS_INIT_LEVEL_MISMATCH; \
+    } while (0)
+
+#endif // !UACPI_BAREBONES_MODE
+
+static uacpi_status table_install_physical_with_origin_unlocked(
+    uacpi_phys_addr phys, enum uacpi_table_origin origin,
+    const uacpi_char *expected_signature, uacpi_table *out_table
+);
+static uacpi_status table_install_with_origin_unlocked(
+    void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+
+UACPI_PACKED(struct uacpi_rxsdt {
+    struct acpi_sdt_hdr hdr;
+    uacpi_u8 ptr_bytes[];
+})
+
+static void dump_table_header(
+    uacpi_phys_addr phys_addr, void *hdr
+)
+{
+    struct acpi_sdt_hdr *sdt = hdr;
+
+    if (uacpi_signatures_match(hdr, ACPI_FACS_SIGNATURE)) {
+        uacpi_info(
+            "FACS 0x%016"UACPI_PRIX64" %08X\n", UACPI_FMT64(phys_addr),
+            sdt->length
+        );
+        return;
+    }
+
+    if (!uacpi_memcmp(hdr, ACPI_RSDP_SIGNATURE, sizeof(ACPI_RSDP_SIGNATURE) - 1)) {
+        struct acpi_rsdp *rsdp = hdr;
+
+        uacpi_info(
+            "RSDP 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s)\n",
+            UACPI_FMT64(phys_addr), rsdp->revision >= 2 ? rsdp->length : 20,
+            rsdp->revision, rsdp->oemid
+        );
+        return;
+    }
+
+    uacpi_info(
+        "%.4s 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s %8.8s)\n",
+        sdt->signature, UACPI_FMT64(phys_addr), sdt->length, sdt->revision,
+        sdt->oemid, sdt->oem_table_id
+    );
+}
+
+static uacpi_status initialize_from_rxsdt(uacpi_phys_addr rxsdt_addr,
+                                          uacpi_size entry_size)
+{
+    struct uacpi_rxsdt *rxsdt;
+    uacpi_size i, entry_bytes, map_len = sizeof(*rxsdt);
+    uacpi_phys_addr entry_addr;
+    uacpi_status ret;
+
+    rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
+    if (rxsdt == UACPI_NULL)
+        return UACPI_STATUS_MAPPING_FAILED;
+
+    dump_table_header(rxsdt_addr, rxsdt);
+
+    ret = uacpi_check_table_signature(rxsdt,
+        entry_size == 8 ? ACPI_XSDT_SIGNATURE : ACPI_RSDT_SIGNATURE);
+    if (uacpi_unlikely_error(ret))
+        goto error_out;
+
+    map_len = rxsdt->hdr.length;
+    uacpi_kernel_unmap(rxsdt, sizeof(*rxsdt));
+
+    if (uacpi_unlikely(map_len < (sizeof(*rxsdt) + entry_size)))
+        return UACPI_STATUS_INVALID_TABLE_LENGTH;
+
+    // Make sure length is aligned to entry size so we don't OOB
+    entry_bytes = map_len - sizeof(*rxsdt);
+    entry_bytes &= ~(entry_size - 1);
+
+    rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
+    if (uacpi_unlikely(rxsdt == UACPI_NULL))
+        return UACPI_STATUS_MAPPING_FAILED;
+
+    ret = uacpi_verify_table_checksum(rxsdt, map_len);
+    if (uacpi_unlikely_error(ret))
+        goto error_out;
+
+    for (i = 0; i < entry_bytes; i += entry_size) {
+        uacpi_u64 entry_phys_addr_large = 0;
+        uacpi_memcpy(&entry_phys_addr_large, &rxsdt->ptr_bytes[i], entry_size);
+
+        if (!entry_phys_addr_large)
+            continue;
+
+        entry_addr = uacpi_truncate_phys_addr_with_warn(entry_phys_addr_large);
+        ret = uacpi_table_install_physical_with_origin(
+            entry_addr, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL, UACPI_NULL
+        );
+        if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+                           ret != UACPI_STATUS_OVERRIDDEN))
+            goto error_out;
+    }
+
+    ret = UACPI_STATUS_OK;
+
+error_out:
+    uacpi_kernel_unmap(rxsdt, map_len);
+    return ret;
+}
+
+static uacpi_status initialize_from_rsdp(void)
+{
+    uacpi_status ret;
+    uacpi_phys_addr rsdp_phys;
+    struct acpi_rsdp *rsdp;
+    uacpi_phys_addr rxsdt;
+    uacpi_size rxsdt_entry_size;
+
+    g_uacpi_rt_ctx.is_rev1 = UACPI_TRUE;
+
+    ret = uacpi_kernel_get_rsdp(&rsdp_phys);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    rsdp = uacpi_kernel_map(rsdp_phys, sizeof(struct acpi_rsdp));
+    if (rsdp == UACPI_NULL)
+        return UACPI_STATUS_MAPPING_FAILED;
+
+    dump_table_header(rsdp_phys, rsdp);
+
+    if (rsdp->revision > 1 && rsdp->xsdt_addr &&
+        !uacpi_check_flag(UACPI_FLAG_BAD_XSDT))
+    {
+        rxsdt = uacpi_truncate_phys_addr_with_warn(rsdp->xsdt_addr);
+        rxsdt_entry_size = 8;
+    } else {
+        rxsdt = (uacpi_phys_addr)rsdp->rsdt_addr;
+        rxsdt_entry_size = 4;
+    }
+
+    uacpi_kernel_unmap(rsdp, sizeof(struct acpi_rsdp));
+
+    if (!rxsdt) {
+        uacpi_error("both RSDT & XSDT tables are NULL!\n");
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+
+    return initialize_from_rxsdt(rxsdt, rxsdt_entry_size);
+}
+
+uacpi_status uacpi_setup_early_table_access(
+    void *temporary_buffer, uacpi_size buffer_size
+)
+{
+    uacpi_status ret;
+
+#ifndef UACPI_BAREBONES_MODE
+    UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_EARLY);
+#endif
+    if (uacpi_unlikely(early_table_access))
+        return UACPI_STATUS_INIT_LEVEL_MISMATCH;
+
+    if (uacpi_unlikely(buffer_size < sizeof(struct uacpi_installed_table)))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    uacpi_logger_initialize();
+
+    tables.dynamic_storage = temporary_buffer;
+    tables.dynamic_capacity = buffer_size / sizeof(struct uacpi_installed_table);
+    early_table_access = UACPI_TRUE;
+
+    ret = initialize_from_rsdp();
+    if (uacpi_unlikely_error(ret))
+        uacpi_deinitialize_tables();
+
+    return ret;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+static uacpi_iteration_decision warn_if_early_referenced(
+    void *user, struct uacpi_installed_table *tbl, uacpi_size idx
+)
+{
+    UACPI_UNUSED(user);
+
+    if (uacpi_unlikely(tbl->reference_count != 0)) {
+        uacpi_warn(
+            "table "UACPI_PRI_TBL_HDR" (%zu) still has %d early reference(s)!\n",
+            UACPI_FMT_TBL_HDR(&tbl->hdr), idx, tbl->reference_count
+        );
+    }
+
+    return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+uacpi_status uacpi_initialize_tables(void)
+{
+    if (early_table_access) {
+        uacpi_size num_tables;
+
+        uacpi_for_each_table(0, warn_if_early_referenced, UACPI_NULL);
+
+        // Reallocate the user buffer into a normal heap array
+        num_tables = table_array_size(&tables);
+        if (num_tables > table_array_inline_capacity(&tables)) {
+            void *new_buf;
+
+            /*
+             * Allocate a new buffer with size equal to exactly the number of
+             * dynamic tables (that live in the user provided temporary buffer).
+             */
+            num_tables -= table_array_inline_capacity(&tables);
+            new_buf = uacpi_kernel_alloc(
+                sizeof(struct uacpi_installed_table) * num_tables
+            );
+            if (uacpi_unlikely(new_buf == UACPI_NULL))
+                return UACPI_STATUS_OUT_OF_MEMORY;
+
+            uacpi_memcpy(new_buf, tables.dynamic_storage,
+                         sizeof(struct uacpi_installed_table) * num_tables);
+            tables.dynamic_storage = new_buf;
+            tables.dynamic_capacity = num_tables;
+        } else {
+            /*
+             * User-provided temporary buffer was not used at all, just remove
+             * any references to it.
+             */
+            tables.dynamic_storage = UACPI_NULL;
+            tables.dynamic_capacity = 0;
+        }
+
+        early_table_access = UACPI_FALSE;
+    } else {
+        uacpi_status ret;
+
+        ret = initialize_from_rsdp();
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    }
+
+    if (!uacpi_is_hardware_reduced()) {
+        struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+        uacpi_table tbl;
+
+        if (fadt->x_firmware_ctrl) {
+            uacpi_status ret;
+
+            ret = table_install_physical_with_origin_unlocked(
+                fadt->x_firmware_ctrl, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
+                ACPI_FACS_SIGNATURE, &tbl
+            );
+            if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+                               ret != UACPI_STATUS_OVERRIDDEN))
+                return ret;
+
+            g_uacpi_rt_ctx.facs = tbl.ptr;
+        }
+    }
+
+    table_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(table_mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    return UACPI_STATUS_OK;
+}
+#endif // !UACPI_BAREBONES_MODE
+
+void uacpi_deinitialize_tables(void)
+{
+    uacpi_size i;
+
+    for (i = 0; i < table_array_size(&tables); ++i) {
+        struct uacpi_installed_table *tbl = table_array_at(&tables, i);
+
+        switch (tbl->origin) {
+#ifndef UACPI_BAREBONES_MODE
+        case UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL:
+            uacpi_free(tbl->ptr, tbl->hdr.length);
+            break;
+#endif
+        case UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL:
+        case UACPI_TABLE_ORIGIN_HOST_PHYSICAL:
+            if (tbl->reference_count != 0)
+                uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (early_table_access) {
+        uacpi_memzero(&tables, sizeof(tables));
+        early_table_access = UACPI_FALSE;
+    } else {
+        table_array_clear(&tables);
+    }
+
+    installation_handler = UACPI_NULL;
+
+#ifndef UACPI_BAREBONES_MODE
+    if (table_mutex)
+        uacpi_kernel_free_mutex(table_mutex);
+
+    table_mutex = UACPI_NULL;
+#endif
+}
+
+uacpi_status uacpi_set_table_installation_handler(
+    uacpi_table_installation_handler handler
+)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (installation_handler != UACPI_NULL && handler != UACPI_NULL)
+        goto out;
+
+    installation_handler = handler;
+
+out:
+    uacpi_release_native_mutex_may_be_null(table_mutex);
+    return ret;
+}
+
+static uacpi_status initialize_fadt(const void*);
+
+static uacpi_u8 table_checksum(void *table, uacpi_size size)
+{
+    uacpi_u8 *bytes = table;
+    uacpi_u8 csum = 0;
+    uacpi_size i;
+
+    for (i = 0; i < size; ++i)
+        csum += bytes[i];
+
+    return csum;
+}
+
+uacpi_status uacpi_verify_table_checksum(void *table, uacpi_size size)
+{
+    uacpi_status ret = UACPI_STATUS_OK;
+    uacpi_u8 csum;
+
+    csum = table_checksum(table, size);
+
+    if (uacpi_unlikely(csum != 0)) {
+        enum uacpi_log_level lvl = UACPI_LOG_WARN;
+        struct acpi_sdt_hdr *hdr = table;
+
+        if (uacpi_check_flag(UACPI_FLAG_BAD_CSUM_FATAL)) {
+            ret = UACPI_STATUS_BAD_CHECKSUM;
+            lvl = UACPI_LOG_ERROR;
+        }
+
+        uacpi_log_lvl(
+            lvl, "invalid table "UACPI_PRI_TBL_HDR" checksum %d!\n",
+            UACPI_FMT_TBL_HDR(hdr), csum
+        );
+    }
+
+    return ret;
+}
+
+uacpi_bool uacpi_signatures_match(const void *const lhs, const void *const rhs)
+{
+    return uacpi_memcmp(lhs, rhs, sizeof(uacpi_object_name)) == 0;
+}
+
+uacpi_status uacpi_check_table_signature(void *table, const uacpi_char *expect)
+{
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    if (!uacpi_signatures_match(table, expect)) {
+        enum uacpi_log_level lvl = UACPI_LOG_WARN;
+        struct acpi_sdt_hdr *hdr = table;
+
+        if (uacpi_check_flag(UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL)) {
+            ret = UACPI_STATUS_INVALID_SIGNATURE;
+            lvl = UACPI_LOG_ERROR;
+        }
+
+        uacpi_log_lvl(
+            lvl,
+            "invalid table "UACPI_PRI_TBL_HDR" signature (expected '%.4s')\n",
+            UACPI_FMT_TBL_HDR(hdr), expect
+        );
+    }
+
+    return ret;
+}
+
+static uacpi_status table_alloc(
+    struct uacpi_installed_table **out_tbl, uacpi_size *out_idx
+)
+{
+    struct uacpi_installed_table *tbl;
+
+    if (early_table_access &&
+        table_array_size(&tables) == table_array_capacity(&tables)) {
+        uacpi_warn("early table access buffer capacity exhausted!\n");
+        return UACPI_STATUS_OUT_OF_MEMORY;
+    }
+
+    tbl = table_array_alloc(&tables);
+    if (uacpi_unlikely(tbl == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    *out_tbl = tbl;
+    *out_idx = table_array_size(&tables) - 1;
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status get_external_table_header(
+    uacpi_phys_addr phys_addr, struct acpi_sdt_hdr *out_hdr
+)
+{
+    void *virt;
+
+    virt = uacpi_kernel_map(phys_addr, sizeof(*out_hdr));
+    if (uacpi_unlikely(virt == UACPI_NULL))
+        return UACPI_STATUS_MAPPING_FAILED;
+
+    uacpi_memcpy(out_hdr, virt, sizeof(*out_hdr));
+
+    uacpi_kernel_unmap(virt,  sizeof(*out_hdr));
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status table_ref_unlocked(struct uacpi_installed_table *tbl)
+{
+    switch (tbl->reference_count) {
+    case 0: {
+        uacpi_status ret;
+
+        if (tbl->flags & UACPI_TABLE_INVALID)
+            return UACPI_STATUS_INVALID_ARGUMENT;
+
+        if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
+            tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
+            break;
+
+        tbl->ptr = uacpi_kernel_map(tbl->phys_addr, tbl->hdr.length);
+        if (uacpi_unlikely(tbl->ptr == UACPI_NULL))
+            return UACPI_STATUS_MAPPING_FAILED;
+
+        if (!(tbl->flags & UACPI_TABLE_CSUM_VERIFIED)) {
+            ret = uacpi_verify_table_checksum(tbl->ptr, tbl->hdr.length);
+            if (uacpi_unlikely_error(ret)) {
+                uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+                tbl->flags |= UACPI_TABLE_INVALID;
+                tbl->ptr = UACPI_NULL;
+                return ret;
+            }
+
+            tbl->flags |= UACPI_TABLE_CSUM_VERIFIED;
+        }
+        break;
+    }
+    case 0xFFFF - 1:
+        uacpi_warn(
+            "too many references for "UACPI_PRI_TBL_HDR
+            ", mapping permanently\n", UACPI_FMT_TBL_HDR(&tbl->hdr)
+        );
+        break;
+    default:
+        break;
+    }
+
+    if (uacpi_likely(tbl->reference_count != 0xFFFF))
+        tbl->reference_count++;
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status table_unref_unlocked(struct uacpi_installed_table *tbl)
+{
+    switch (tbl->reference_count) {
+    case 0:
+        uacpi_warn(
+            "tried to unref table "UACPI_PRI_TBL_HDR" with no references\n",
+            UACPI_FMT_TBL_HDR(&tbl->hdr)
+        );
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    case 1:
+        if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
+            tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
+            break;
+
+        uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+        tbl->ptr = UACPI_NULL;
+        break;
+    case 0xFFFF:
+        /*
+         * Consider the reference count (overflow) of 0xFFFF to be a permanently
+         * mapped table as we don't know the actual number of references.
+         */
+        return UACPI_STATUS_OK;
+    default:
+        break;
+    }
+
+    tbl->reference_count--;
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status verify_and_install_table(
+    struct acpi_sdt_hdr *hdr, uacpi_phys_addr phys_addr, void *virt_addr,
+    enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+    struct uacpi_installed_table *table;
+    uacpi_bool is_fadt;
+    uacpi_size idx;
+    uacpi_u8 flags = 0;
+
+    is_fadt = uacpi_signatures_match(hdr->signature, ACPI_FADT_SIGNATURE);
+
+    /*
+     * FACS is the only(?) table without a checksum because it has OSPM
+     * writable fields. Don't try to validate it here.
+     */
+    if (uacpi_signatures_match(hdr->signature, ACPI_FACS_SIGNATURE)) {
+        flags |= UACPI_TABLE_CSUM_VERIFIED;
+    } else if (uacpi_check_flag(UACPI_FLAG_PROACTIVE_TBL_CSUM) || is_fadt ||
+               out_table != UACPI_NULL) {
+        void *mapping = virt_addr;
+
+        // We may already have a valid mapping, reuse it if we do
+        if (mapping == UACPI_NULL)
+            mapping = uacpi_kernel_map(phys_addr, hdr->length);
+        if (uacpi_unlikely(mapping == UACPI_NULL))
+            return UACPI_STATUS_MAPPING_FAILED;
+
+        ret = uacpi_verify_table_checksum(mapping, hdr->length);
+        if (uacpi_likely_success(ret)) {
+            if (is_fadt)
+                ret = initialize_fadt(mapping);
+            flags |= UACPI_TABLE_CSUM_VERIFIED;
+        }
+
+        if (virt_addr == UACPI_NULL)
+            uacpi_kernel_unmap(mapping, hdr->length);
+
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    }
+
+    if (uacpi_signatures_match(hdr->signature, ACPI_DSDT_SIGNATURE))
+        g_uacpi_rt_ctx.is_rev1 = hdr->revision < 2;
+
+    ret = table_alloc(&table, &idx);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    dump_table_header(phys_addr, hdr);
+
+    uacpi_memcpy(&table->hdr, hdr, sizeof(*hdr));
+    table->reference_count = 0;
+    table->phys_addr = phys_addr;
+    table->ptr = virt_addr;
+    table->flags = flags;
+    table->origin = origin;
+
+    if (out_table == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    table->reference_count++;
+    out_table->ptr = virt_addr;
+    out_table->index = idx;
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_table_override(
+    uacpi_table_installation_disposition disposition, uacpi_u64 address,
+    uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+
+    switch (disposition) {
+    case UACPI_TABLE_INSTALLATION_DISPOSITON_VIRTUAL_OVERRIDE:
+        ret = table_install_with_origin_unlocked(
+            UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)address),
+            UACPI_TABLE_ORIGIN_HOST_VIRTUAL,
+            out_table
+        );
+        return ret;
+    case UACPI_TABLE_INSTALLATION_DISPOSITON_PHYSICAL_OVERRIDE:
+        return table_install_physical_with_origin_unlocked(
+            (uacpi_phys_addr)address,
+            UACPI_TABLE_ORIGIN_HOST_PHYSICAL,
+            UACPI_NULL,
+            out_table
+        );
+    default:
+        uacpi_error("invalid table installation disposition %d\n", disposition);
+        return UACPI_STATUS_INTERNAL_ERROR;
+    }
+}
+
+static uacpi_status table_install_physical_with_origin_unlocked(
+    uacpi_phys_addr phys, enum uacpi_table_origin origin,
+    const uacpi_char *expected_signature, uacpi_table *out_table
+)
+{
+    struct acpi_sdt_hdr hdr;
+    void *virt = UACPI_NULL;
+    uacpi_status ret;
+
+    ret = get_external_table_header(phys, &hdr);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (uacpi_unlikely(hdr.length < sizeof(struct acpi_sdt_hdr))) {
+        uacpi_error("invalid table '%.4s' (0x%016"UACPI_PRIX64") size: %u\n",
+                    hdr.signature, UACPI_FMT64(phys), hdr.length);
+        return UACPI_STATUS_INVALID_TABLE_LENGTH;
+    }
+
+    if (expected_signature != UACPI_NULL) {
+        ret = uacpi_check_table_signature(&hdr, expected_signature);
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    }
+
+    if (installation_handler != UACPI_NULL || out_table != UACPI_NULL) {
+        virt = uacpi_kernel_map(phys, hdr.length);
+        if (uacpi_unlikely(!virt))
+            return UACPI_STATUS_MAPPING_FAILED;
+    }
+
+    if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL &&
+        installation_handler != UACPI_NULL) {
+        uacpi_u64 override;
+        uacpi_table_installation_disposition disposition;
+
+        disposition = installation_handler(virt, &override);
+
+        switch (disposition) {
+        case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
+            break;
+        case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
+            uacpi_info(
+                "table '%.4s' (0x%016"UACPI_PRIX64") installation denied "
+                "by host\n", hdr.signature, UACPI_FMT64(phys)
+            );
+            ret = UACPI_STATUS_DENIED;
+            goto out;
+
+        default:
+            uacpi_info(
+                "table '%.4s' (0x%016"UACPI_PRIX64") installation "
+                "overridden by host\n", hdr.signature, UACPI_FMT64(phys)
+            );
+
+            ret = handle_table_override(disposition, override, out_table);
+            if (uacpi_likely_success(ret))
+                ret = UACPI_STATUS_OVERRIDDEN;
+
+            goto out;
+        }
+    }
+
+    ret = verify_and_install_table(&hdr, phys, virt, origin, out_table);
+out:
+    // We don't unmap only in this case
+    if (ret == UACPI_STATUS_OK && out_table != UACPI_NULL)
+        return ret;
+
+    if (virt != UACPI_NULL)
+        uacpi_kernel_unmap(virt, hdr.length);
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_table_install_physical_with_origin(
+    uacpi_phys_addr phys, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = table_install_physical_with_origin_unlocked(
+        phys, origin, UACPI_NULL, out_table
+    );
+    uacpi_release_native_mutex_may_be_null(table_mutex);
+
+    return ret;
+}
+
+static uacpi_status table_install_with_origin_unlocked(
+    void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+    struct acpi_sdt_hdr *hdr = virt;
+
+    if (uacpi_unlikely(hdr->length < sizeof(struct acpi_sdt_hdr))) {
+        uacpi_error("invalid table '%.4s' (%p) size: %u\n",
+                    hdr->signature, virt, hdr->length);
+        return UACPI_STATUS_INVALID_TABLE_LENGTH;
+    }
+
+#ifndef UACPI_BAREBONES_MODE
+    if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL &&
+        installation_handler != UACPI_NULL) {
+        uacpi_u64 override;
+        uacpi_table_installation_disposition disposition;
+
+        disposition = installation_handler(virt, &override);
+
+        switch (disposition) {
+        case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
+            break;
+        case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
+            uacpi_info(
+                "table "UACPI_PRI_TBL_HDR" installation denied by host\n",
+                UACPI_FMT_TBL_HDR(hdr)
+            );
+            return UACPI_STATUS_DENIED;
+
+        default: {
+            uacpi_status ret;
+            uacpi_info(
+                "table "UACPI_PRI_TBL_HDR" installation overridden by host\n",
+                UACPI_FMT_TBL_HDR(hdr)
+            );
+
+            ret = handle_table_override(disposition, override, out_table);
+            if (uacpi_likely_success(ret))
+                ret = UACPI_STATUS_OVERRIDDEN;
+
+            return ret;
+        }
+        }
+    }
+#endif
+
+    return verify_and_install_table(
+        hdr, 0, virt, origin, out_table
+    );
+}
+
+uacpi_status uacpi_table_install_with_origin(
+    void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = table_install_with_origin_unlocked(virt, origin, out_table);
+
+    uacpi_release_native_mutex_may_be_null(table_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_table_install(void *virt, uacpi_table *out_table)
+{
+    ENSURE_TABLES_ONLINE();
+
+    return uacpi_table_install_with_origin(
+        virt, UACPI_TABLE_ORIGIN_HOST_VIRTUAL, out_table
+    );
+}
+
+uacpi_status uacpi_table_install_physical(
+    uacpi_phys_addr addr, uacpi_table *out_table
+)
+{
+    ENSURE_TABLES_ONLINE();
+
+    return uacpi_table_install_physical_with_origin(
+        addr, UACPI_TABLE_ORIGIN_HOST_PHYSICAL, out_table
+    );
+}
+
+uacpi_status uacpi_for_each_table(
+    uacpi_size base_idx, uacpi_table_iteration_callback cb, void *user
+)
+{
+    uacpi_status ret;
+    uacpi_size idx;
+    struct uacpi_installed_table *tbl;
+    uacpi_iteration_decision dec;
+
+    ENSURE_TABLES_ONLINE();
+
+    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    for (idx = base_idx; idx < table_array_size(&tables); ++idx) {
+        tbl = table_array_at(&tables, idx);
+
+        if (tbl->flags & UACPI_TABLE_INVALID)
+            continue;
+
+        dec = cb(user, tbl, idx);
+        if (dec == UACPI_ITERATION_DECISION_BREAK)
+            break;
+    }
+
+    uacpi_release_native_mutex_may_be_null(table_mutex);
+    return ret;
+}
+
+enum search_type {
+    SEARCH_TYPE_BY_ID,
+    SEARCH_TYPE_MATCH,
+};
+
+struct table_search_ctx {
+    union {
+        const uacpi_table_identifiers *id;
+        uacpi_table_match_callback match_cb;
+    };
+
+    uacpi_table *out_table;
+    uacpi_u8 search_type;
+    uacpi_status status;
+};
+
+static uacpi_iteration_decision do_search_tables(
+    void *user, struct uacpi_installed_table *tbl, uacpi_size idx
+)
+{
+    struct table_search_ctx *ctx = user;
+    uacpi_table *out_table;
+    uacpi_status ret;
+
+    switch (ctx->search_type) {
+    case SEARCH_TYPE_BY_ID: {
+        const uacpi_table_identifiers *id = ctx->id;
+
+        if (!uacpi_signatures_match(&id->signature, tbl->hdr.signature))
+            return UACPI_ITERATION_DECISION_CONTINUE;
+        if (id->oemid[0] != '\0' &&
+            uacpi_memcmp(id->oemid, tbl->hdr.oemid, sizeof(id->oemid)) != 0)
+            return UACPI_ITERATION_DECISION_CONTINUE;
+
+        if (id->oem_table_id[0] != '\0' &&
+            uacpi_memcmp(id->oem_table_id, tbl->hdr.oem_table_id,
+                         sizeof(id->oem_table_id)) != 0)
+            return UACPI_ITERATION_DECISION_CONTINUE;
+
+        break;
+    }
+
+    case SEARCH_TYPE_MATCH:
+        if (!ctx->match_cb(tbl))
+            return UACPI_ITERATION_DECISION_CONTINUE;
+        break;
+
+    default:
+        ctx->status = UACPI_STATUS_INVALID_ARGUMENT;
+        return UACPI_ITERATION_DECISION_BREAK;
+    }
+
+    ret = table_ref_unlocked(tbl);
+    if (uacpi_likely_success(ret)) {
+        out_table = ctx->out_table;
+        out_table->ptr = tbl->ptr;
+        out_table->index = idx;
+        ctx->status = ret;
+        return UACPI_ITERATION_DECISION_BREAK;
+    }
+
+    /*
+     * Don't abort nor propagate bad checksums, just pretend this table never
+     * existed and go on with the search.
+     */
+    if (ret == UACPI_STATUS_BAD_CHECKSUM)
+        return UACPI_ITERATION_DECISION_CONTINUE;
+
+    ctx->status = ret;
+    return UACPI_ITERATION_DECISION_BREAK;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+uacpi_status uacpi_table_match(
+    uacpi_size base_idx, uacpi_table_match_callback cb, uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+    struct table_search_ctx ctx = { 0 };
+
+    ctx.match_cb = cb;
+    ctx.search_type = SEARCH_TYPE_MATCH;
+    ctx.out_table = out_table;
+    ctx.status = UACPI_STATUS_NOT_FOUND;
+
+    ret = uacpi_for_each_table(base_idx, do_search_tables, &ctx);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return ctx.status;
+}
+#endif
+
+static uacpi_status find_table(
+    uacpi_size base_idx, const uacpi_table_identifiers *id,
+    uacpi_table *out_table
+)
+{
+    uacpi_status ret;
+    struct table_search_ctx ctx = { 0 };
+
+    ctx.id = id;
+    ctx.out_table = out_table;
+    ctx.search_type = SEARCH_TYPE_BY_ID;
+    ctx.status = UACPI_STATUS_NOT_FOUND;
+
+    ret = uacpi_for_each_table(base_idx, do_search_tables, &ctx);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return ctx.status;
+}
+
+uacpi_status uacpi_table_find_by_signature(
+    const uacpi_char *signature_string, struct uacpi_table *out_table
+)
+{
+    struct uacpi_table_identifiers id = { 0 };
+
+    id.signature.text[0] = signature_string[0];
+    id.signature.text[1] = signature_string[1];
+    id.signature.text[2] = signature_string[2];
+    id.signature.text[3] = signature_string[3];
+
+    ENSURE_TABLES_ONLINE();
+
+    return find_table(0, &id, out_table);
+}
+
+uacpi_status uacpi_table_find_next_with_same_signature(
+    uacpi_table *in_out_table
+)
+{
+    struct uacpi_table_identifiers id = { 0 };
+
+    ENSURE_TABLES_ONLINE();
+
+    if (uacpi_unlikely(in_out_table->ptr == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    uacpi_memcpy(&id.signature, in_out_table->hdr->signature,
+                 sizeof(id.signature));
+    uacpi_table_unref(in_out_table);
+
+    return find_table(in_out_table->index + 1, &id, in_out_table);
+}
+
+uacpi_status uacpi_table_find(
+    const uacpi_table_identifiers *id, uacpi_table *out_table
+)
+{
+    ENSURE_TABLES_ONLINE();
+
+    return find_table(0, id, out_table);
+}
+
+#define TABLE_CTL_SET_FLAGS (1 << 0)
+#define TABLE_CTL_CLEAR_FLAGS (1 << 1)
+#define TABLE_CTL_VALIDATE_SET_FLAGS (1 << 2)
+#define TABLE_CTL_VALIDATE_CLEAR_FLAGS (1 << 3)
+#define TABLE_CTL_GET (1 << 4)
+#define TABLE_CTL_PUT (1 << 5)
+
+struct table_ctl_request {
+    uacpi_u8 type;
+
+    uacpi_u8 expect_set;
+    uacpi_u8 expect_clear;
+    uacpi_u8 set;
+    uacpi_u8 clear;
+
+    void *out_tbl;
+};
+
+static uacpi_status table_ctl(uacpi_size idx, struct table_ctl_request *req)
+{
+    uacpi_status ret;
+    struct uacpi_installed_table *tbl;
+
+    ENSURE_TABLES_ONLINE();
+
+    ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (uacpi_unlikely(table_array_size(&tables) <= idx)) {
+        uacpi_error(
+            "requested invalid table index %zu (%zu tables installed)\n",
+            idx, table_array_size(&tables)
+        );
+        ret = UACPI_STATUS_INVALID_ARGUMENT;
+        goto out;
+    }
+
+    tbl = table_array_at(&tables, idx);
+    if (uacpi_unlikely(tbl->flags & UACPI_TABLE_INVALID))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    if (req->type & TABLE_CTL_VALIDATE_SET_FLAGS) {
+        uacpi_u8 mask = req->expect_set;
+
+        if (uacpi_unlikely((tbl->flags & mask) != mask)) {
+            uacpi_error(
+                "unexpected table '%.4s' flags %02X, expected %02X to be set\n",
+                tbl->hdr.signature, tbl->flags, mask
+            );
+            ret = UACPI_STATUS_INVALID_ARGUMENT;
+            goto out;
+        }
+    }
+
+    if (req->type & TABLE_CTL_VALIDATE_CLEAR_FLAGS) {
+        uacpi_u8 mask = req->expect_clear;
+
+        if (uacpi_unlikely((tbl->flags & mask) != 0)) {
+            uacpi_error(
+                "unexpected table '%.4s' flags %02X, expected %02X "
+                "to be clear\n", tbl->hdr.signature, tbl->flags, mask
+            );
+            ret = UACPI_STATUS_ALREADY_EXISTS;
+            goto out;
+        }
+    }
+
+    if (req->type & TABLE_CTL_GET) {
+        ret = table_ref_unlocked(tbl);
+        if (uacpi_unlikely_error(ret))
+            goto out;
+
+        req->out_tbl = tbl->ptr;
+    }
+
+    if (req->type & TABLE_CTL_PUT) {
+        ret = table_unref_unlocked(tbl);
+        if (uacpi_unlikely_error(ret))
+            goto out;
+    }
+
+    if (req->type & TABLE_CTL_SET_FLAGS)
+        tbl->flags |= req->set;
+    if (req->type & TABLE_CTL_CLEAR_FLAGS)
+        tbl->flags &= ~req->clear;
+
+out:
+    uacpi_release_native_mutex_may_be_null(table_mutex);
+    return ret;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+uacpi_status uacpi_table_load_with_cause(
+    uacpi_size idx, enum uacpi_table_load_cause cause
+)
+{
+    uacpi_status ret;
+    struct table_ctl_request req = {
+        .type = TABLE_CTL_SET_FLAGS | TABLE_CTL_VALIDATE_CLEAR_FLAGS |
+                TABLE_CTL_GET,
+        .set = UACPI_TABLE_LOADED,
+        .expect_clear = UACPI_TABLE_LOADED,
+    };
+
+    ret = table_ctl(idx, &req);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_execute_table(req.out_tbl, cause);
+
+    req.type = TABLE_CTL_PUT;
+    table_ctl(idx, &req);
+    return ret;
+}
+
+uacpi_status uacpi_table_load(uacpi_size idx)
+{
+    return uacpi_table_load_with_cause(idx, UACPI_TABLE_LOAD_CAUSE_HOST);
+}
+
+void uacpi_table_mark_as_loaded(uacpi_size idx)
+{
+    struct table_ctl_request req = {
+        .type = TABLE_CTL_SET_FLAGS, .set = UACPI_TABLE_LOADED
+    };
+
+    table_ctl(idx, &req);
+}
+#endif // !UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_table_ref(uacpi_table *tbl)
+{
+    struct table_ctl_request req = {
+        .type = TABLE_CTL_GET
+    };
+
+    return table_ctl(tbl->index, &req);
+}
+
+uacpi_status uacpi_table_unref(uacpi_table *tbl)
+{
+    struct table_ctl_request req = {
+        .type = TABLE_CTL_PUT
+    };
+
+    return table_ctl(tbl->index, &req);
+}
+
+uacpi_u16 fadt_version_sizes[] = {
+    116, 132, 244, 244, 268, 276
+};
+
+static void fadt_ensure_correct_revision(struct acpi_fadt *fadt)
+{
+    uacpi_size current_rev, rev;
+
+    current_rev = fadt->hdr.revision;
+
+    for (rev = 0; rev < UACPI_ARRAY_SIZE(fadt_version_sizes); ++rev) {
+        if (fadt->hdr.length <= fadt_version_sizes[rev])
+            break;
+    }
+
+    if (rev == UACPI_ARRAY_SIZE(fadt_version_sizes)) {
+        uacpi_trace(
+            "FADT revision (%zu) is likely greater than the last "
+            "supported, reducing to %zu\n", current_rev, rev
+        );
+        fadt->hdr.revision = rev;
+        return;
+    }
+
+    rev++;
+
+    if (current_rev != rev && !(rev == 3 && current_rev == 4)) {
+        uacpi_warn(
+            "FADT length %u doesn't match expected for revision %zu, "
+            "assuming version %zu\n", fadt->hdr.length, current_rev,
+            rev
+        );
+        fadt->hdr.revision = rev;
+    }
+}
+
+static void gas_init_system_io(
+    struct acpi_gas *gas, uacpi_u64 address, uacpi_u8 byte_size
+)
+{
+    gas->address = address;
+    gas->address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO;
+    gas->register_bit_width = UACPI_MIN(255, byte_size * 8);
+    gas->register_bit_offset = 0;
+    gas->access_size = 0;
+}
+
+
+struct register_description {
+    uacpi_size offset, xoffset;
+    uacpi_size length_offset;
+};
+
+#define fadt_offset(field) uacpi_offsetof(struct acpi_fadt, field)
+
+/*
+ * We convert all the legacy registers into GAS format and write them into
+ * the x_* fields for convenience and faster access at runtime.
+ */
+static struct register_description fadt_registers[] = {
+    {
+        .offset = fadt_offset(pm1a_evt_blk),
+        .xoffset = fadt_offset(x_pm1a_evt_blk),
+        .length_offset = fadt_offset(pm1_evt_len),
+    },
+    {
+        .offset = fadt_offset(pm1b_evt_blk),
+        .xoffset = fadt_offset(x_pm1b_evt_blk),
+        .length_offset = fadt_offset(pm1_evt_len),
+    },
+    {
+        .offset = fadt_offset(pm1a_cnt_blk),
+        .xoffset = fadt_offset(x_pm1a_cnt_blk),
+        .length_offset = fadt_offset(pm1_cnt_len),
+    },
+    {
+        .offset = fadt_offset(pm1b_cnt_blk),
+        .xoffset = fadt_offset(x_pm1b_cnt_blk),
+        .length_offset = fadt_offset(pm1_cnt_len),
+    },
+    {
+        .offset = fadt_offset(pm2_cnt_blk),
+        .xoffset = fadt_offset(x_pm2_cnt_blk),
+        .length_offset = fadt_offset(pm2_cnt_len),
+    },
+    {
+        .offset = fadt_offset(pm_tmr_blk),
+        .xoffset = fadt_offset(x_pm_tmr_blk),
+        .length_offset = fadt_offset(pm_tmr_len),
+    },
+    {
+        .offset = fadt_offset(gpe0_blk),
+        .xoffset = fadt_offset(x_gpe0_blk),
+        .length_offset = fadt_offset(gpe0_blk_len),
+    },
+    {
+        .offset = fadt_offset(gpe1_blk),
+        .xoffset = fadt_offset(x_gpe1_blk),
+        .length_offset = fadt_offset(gpe1_blk_len),
+    },
+};
+
+static void *fadt_relative(uacpi_size offset)
+{
+    return ((uacpi_u8*)&g_uacpi_rt_ctx.fadt) + offset;
+}
+
+static void convert_registers_to_gas(void)
+{
+    uacpi_size i;
+    struct register_description *desc;
+    struct acpi_gas *gas;
+    uacpi_u32 legacy_addr;
+    uacpi_u8 length;
+
+    for (i = 0; i < UACPI_ARRAY_SIZE(fadt_registers); ++i) {
+        desc = &fadt_registers[i];
+
+        legacy_addr = *(uacpi_u32*)fadt_relative(desc->offset);
+        length = *(uacpi_u8*)fadt_relative(desc->length_offset);
+        gas = fadt_relative(desc->xoffset);
+
+        if (gas->address)
+            continue;
+
+        gas_init_system_io(gas, legacy_addr, length);
+    }
+}
+
+#ifndef UACPI_BAREBONES_MODE
+static void split_one_block(
+    struct acpi_gas *src, struct acpi_gas *dst0, struct acpi_gas *dst1
+)
+{
+    uacpi_size byte_length;
+
+    if (src->address == 0)
+        return;
+
+    byte_length = src->register_bit_width / 8;
+    byte_length /= 2;
+
+    gas_init_system_io(dst0, src->address, byte_length);
+    gas_init_system_io(dst1, src->address + byte_length, byte_length);
+}
+
+static void split_event_blocks(void)
+{
+    split_one_block(
+        &g_uacpi_rt_ctx.fadt.x_pm1a_evt_blk,
+        &g_uacpi_rt_ctx.pm1a_status_blk,
+        &g_uacpi_rt_ctx.pm1a_enable_blk
+    );
+    split_one_block(
+        &g_uacpi_rt_ctx.fadt.x_pm1b_evt_blk,
+        &g_uacpi_rt_ctx.pm1b_status_blk,
+        &g_uacpi_rt_ctx.pm1b_enable_blk
+    );
+}
+#endif // !UACPI_BAREBONES_MODE
+
+static uacpi_status initialize_fadt(const void *virt)
+{
+    uacpi_status ret;
+    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+    const struct acpi_sdt_hdr *hdr = virt;
+
+    /*
+     * Here we (roughly) follow ACPICA initialization sequence to make sure we
+     * handle potential BIOS quirks with garbage inside FADT correctly.
+     */
+
+    uacpi_memcpy(fadt, hdr, UACPI_MIN(sizeof(*fadt), hdr->length));
+
+#if !defined(UACPI_REDUCED_HARDWARE) && !defined(UACPI_BAREBONES_MODE)
+    g_uacpi_rt_ctx.is_hardware_reduced = fadt->flags & ACPI_HW_REDUCED_ACPI;
+#endif
+
+    fadt_ensure_correct_revision(fadt);
+
+    /*
+     * These are reserved prior to version 3, so zero them out to work around
+     * BIOS implementations that might dirty these.
+     */
+    if (fadt->hdr.revision <= 2) {
+        fadt->preferred_pm_profile = 0;
+        fadt->pstate_cnt = 0;
+        fadt->cst_cnt = 0;
+        fadt->iapc_boot_arch = 0;
+    }
+
+    if (!fadt->x_dsdt)
+        fadt->x_dsdt = fadt->dsdt;
+
+    if (fadt->x_dsdt) {
+        ret = table_install_physical_with_origin_unlocked(
+            fadt->x_dsdt, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
+            ACPI_DSDT_SIGNATURE, UACPI_NULL
+        );
+        if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+                           ret != UACPI_STATUS_OVERRIDDEN))
+            return ret;
+    }
+
+    /*
+     * Unconditionally use 32 bit FACS if it exists, as 64 bit FACS is known
+     * to cause issues on some firmware:
+     * https://bugzilla.kernel.org/show_bug.cgi?id=74021
+     *
+     * Note that we don't install it here as FACS needs permanent mapping, which
+     * we might not be able to obtain at this point in case of early table
+     * access.
+     */
+    if (fadt->firmware_ctrl)
+        fadt->x_firmware_ctrl = fadt->firmware_ctrl;
+
+    if (!uacpi_is_hardware_reduced()) {
+        convert_registers_to_gas();
+#ifndef UACPI_BAREBONES_MODE
+        split_event_blocks();
+#endif
+    }
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_table_fadt(struct acpi_fadt **out_fadt)
+{
+    ENSURE_TABLES_ONLINE();
+
+    *out_fadt = &g_uacpi_rt_ctx.fadt;
+    return UACPI_STATUS_OK;
+}