[ACPI_NEW] Import uACPI 2.1.1

drivers/bus/acpi_new/uacpi/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2025 Daniil Tatianin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

drivers/bus/acpi_new/uacpi/include/uacpi/context.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Set the minimum log level to be accepted by the logging facilities. Any logs
+ * below this level are discarded and not passed to uacpi_kernel_log, etc.
+ *
+ * 0 is treated as a special value that resets the setting to the default value.
+ *
+ * E.g. for a log level of UACPI_LOG_INFO:
+ *   UACPI_LOG_DEBUG -> discarded
+ *   UACPI_LOG_TRACE -> discarded
+ *   UACPI_LOG_INFO -> allowed
+ *   UACPI_LOG_WARN -> allowed
+ *   UACPI_LOG_ERROR -> allowed
+ */
+void uacpi_context_set_log_level(uacpi_log_level);
+
+/*
+ * Enables table checksum validation at installation time instead of first use.
+ * Note that this makes uACPI map the entire table at once, which not all
+ * hosts are able to handle at early init.
+ */
+void uacpi_context_set_proactive_table_checksum(uacpi_bool);
+
+#ifndef UACPI_BAREBONES_MODE
+/*
+ * Set the maximum number of seconds a While loop is allowed to run for before
+ * getting timed out.
+ *
+ * 0 is treated a special value that resets the setting to the default value.
+ */
+void uacpi_context_set_loop_timeout(uacpi_u32 seconds);
+
+/*
+ * Set the maximum call stack depth AML can reach before getting aborted.
+ *
+ * 0 is treated as a special value that resets the setting to the default value.
+ */
+void uacpi_context_set_max_call_stack_depth(uacpi_u32 depth);
+
+uacpi_u32 uacpi_context_get_loop_timeout(void);
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/event.h

@@ -0,0 +1,286 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/uacpi.h>
+#include <uacpi/acpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_fixed_event {
+    UACPI_FIXED_EVENT_TIMER_STATUS = 1,
+    UACPI_FIXED_EVENT_POWER_BUTTON,
+    UACPI_FIXED_EVENT_SLEEP_BUTTON,
+    UACPI_FIXED_EVENT_RTC,
+    UACPI_FIXED_EVENT_MAX = UACPI_FIXED_EVENT_RTC,
+} uacpi_fixed_event;
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_fixed_event_handler(
+    uacpi_fixed_event event, uacpi_interrupt_handler handler, uacpi_handle user
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_fixed_event_handler(
+    uacpi_fixed_event event
+))
+
+/*
+ * Enable/disable a fixed event. Note that the event is automatically enabled
+ * upon installing a handler to it.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_enable_fixed_event(uacpi_fixed_event event)
+)
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_disable_fixed_event(uacpi_fixed_event event)
+)
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_clear_fixed_event(uacpi_fixed_event event)
+)
+
+typedef enum uacpi_event_info {
+    // Event is enabled in software
+    UACPI_EVENT_INFO_ENABLED = (1 << 0),
+
+    // Event is enabled in software (only for wake)
+    UACPI_EVENT_INFO_ENABLED_FOR_WAKE = (1 << 1),
+
+    // Event is masked
+    UACPI_EVENT_INFO_MASKED = (1 << 2),
+
+    // Event has a handler attached
+    UACPI_EVENT_INFO_HAS_HANDLER = (1 << 3),
+
+    // Hardware enable bit is set
+    UACPI_EVENT_INFO_HW_ENABLED = (1 << 4),
+
+    // Hardware status bit is set
+    UACPI_EVENT_INFO_HW_STATUS = (1 << 5),
+} uacpi_event_info;
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_fixed_event_info(
+    uacpi_fixed_event event, uacpi_event_info *out_info
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_gpe_info(
+   uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+   uacpi_event_info *out_info
+))
+
+// Set if the handler wishes to reenable the GPE it just handled
+#define UACPI_GPE_REENABLE (1 << 7)
+
+typedef uacpi_interrupt_ret (*uacpi_gpe_handler)(
+    uacpi_handle ctx, uacpi_namespace_node *gpe_device, uacpi_u16 idx
+);
+
+typedef enum uacpi_gpe_triggering {
+    UACPI_GPE_TRIGGERING_LEVEL = 0,
+    UACPI_GPE_TRIGGERING_EDGE = 1,
+    UACPI_GPE_TRIGGERING_MAX = UACPI_GPE_TRIGGERING_EDGE,
+} uacpi_gpe_triggering;
+
+const uacpi_char *uacpi_gpe_triggering_to_string(
+    uacpi_gpe_triggering triggering
+);
+
+/*
+ * Installs a handler to the provided GPE at 'idx' controlled by device
+ * 'gpe_device'. The GPE is automatically disabled & cleared according to the
+ * configured triggering upon invoking the handler. The event is optionally
+ * re-enabled (by returning UACPI_GPE_REENABLE from the handler)
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_handler(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_gpe_triggering triggering, uacpi_gpe_handler handler, uacpi_handle ctx
+))
+
+/*
+ * Installs a raw handler to the provided GPE at 'idx' controlled by device
+ * 'gpe_device'. The handler is dispatched immediately after the event is
+ * received, status & enable bits are untouched.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_handler_raw(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_gpe_triggering triggering, uacpi_gpe_handler handler, uacpi_handle ctx
+))
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_gpe_handler(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx, uacpi_gpe_handler handler
+))
+
+/*
+ * Marks the GPE 'idx' managed by 'gpe_device' as wake-capable. 'wake_device' is
+ * optional and configures the GPE to generate an implicit notification whenever
+ * an event occurs.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_setup_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+    uacpi_namespace_node *wake_device
+))
+
+/*
+ * Mark a GPE managed by 'gpe_device' as enabled/disabled for wake. The GPE must
+ * have previously been marked by calling uacpi_gpe_setup_for_wake. This
+ * function only affects the GPE enable register state following the call to
+ * uacpi_gpe_enable_all_for_wake.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_gpe_for_wake(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Finalize GPE initialization by enabling all GPEs not configured for wake and
+ * having a matching AML handler detected.
+ *
+ * This should be called after the kernel power managment subsystem has
+ * enumerated all of the devices, executing their _PRW methods etc., and
+ * marking those it wishes to use for wake by calling uacpi_setup_gpe_for_wake
+ * or uacpi_mark_gpe_for_wake.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_finalize_gpe_initialization(void)
+)
+
+/*
+ * Enable/disable a general purpose event managed by 'gpe_device'. Internally
+ * this uses reference counting to make sure a GPE is not disabled until all
+ * possible users of it do so. GPEs not marked for wake are enabled
+ * automatically so this API is only needed for wake events or those that don't
+ * have a corresponding AML handler.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Clear the status bit of the event 'idx' managed by 'gpe_device'.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_clear_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Suspend/resume a general purpose event managed by 'gpe_device'. This bypasses
+ * the reference counting mechanism and unconditionally clears/sets the
+ * corresponding bit in the enable registers. This is used for switching the GPE
+ * to poll mode.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_suspend_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_resume_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Finish handling the GPE managed by 'gpe_device' at 'idx'. This clears the
+ * status registers if it hasn't been cleared yet and re-enables the event if
+ * it was enabled before.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_finish_handling_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Hard mask/umask a general purpose event at 'idx' managed by 'gpe_device'.
+ * This is used to permanently silence an event so that further calls to
+ * enable/disable as well as suspend/resume get ignored. This might be necessary
+ * for GPEs that cause an event storm due to the kernel's inability to properly
+ * handle them. The only way to enable a masked event is by a call to unmask.
+ *
+ * NOTE: 'gpe_device' may be null for GPEs managed by \_GPE
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_mask_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_unmask_gpe(
+    uacpi_namespace_node *gpe_device, uacpi_u16 idx
+))
+
+/*
+ * Disable all GPEs currently set up on the system.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_disable_all_gpes(void)
+)
+
+/*
+ * Enable all GPEs not marked as wake. This is only needed after the system
+ * wakes from a shallow sleep state and is called automatically by wake code.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_all_runtime_gpes(void)
+)
+
+/*
+ * Enable all GPEs marked as wake. This is only needed before the system goes
+ * to sleep is called automatically by sleep code.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_enable_all_wake_gpes(void)
+)
+
+/*
+ * Install/uninstall a new GPE block, usually defined by a device in the
+ * namespace with a _HID of ACPI0006.
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_install_gpe_block(
+    uacpi_namespace_node *gpe_device, uacpi_u64 address,
+    uacpi_address_space address_space, uacpi_u16 num_registers,
+    uacpi_u32 irq
+))
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_uninstall_gpe_block(
+    uacpi_namespace_node *gpe_device
+))
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/helpers.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#ifdef __cplusplus
+#define UACPI_STATIC_ASSERT static_assert
+#else
+#define UACPI_STATIC_ASSERT _Static_assert
+#endif
+
+#define UACPI_BUILD_BUG_ON_WITH_MSG(expr, msg) UACPI_STATIC_ASSERT(!(expr), msg)
+
+#define UACPI_BUILD_BUG_ON(expr) \
+    UACPI_BUILD_BUG_ON_WITH_MSG(expr, "BUILD BUG: " #expr " evaluated to true")
+
+#define UACPI_EXPECT_SIZEOF(type, size)                        \
+    UACPI_BUILD_BUG_ON_WITH_MSG(sizeof(type) != size,          \
+                                "BUILD BUG: invalid type size")

drivers/bus/acpi_new/uacpi/include/uacpi/internal/compiler.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <uacpi/platform/compiler.h>

drivers/bus/acpi_new/uacpi/include/uacpi/internal/context.h

@@ -0,0 +1,155 @@
+#pragma once
+
+#include <uacpi/acpi.h>
+#include <uacpi/types.h>
+#include <uacpi/uacpi.h>
+#include <uacpi/internal/dynamic_array.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/context.h>
+
+struct uacpi_runtime_context {
+    /*
+     * A local copy of FADT that has been verified & converted to most optimal
+     * format for faster access to the registers.
+     */
+    struct acpi_fadt fadt;
+
+    uacpi_u64 flags;
+
+#ifndef UACPI_BAREBONES_MODE
+    /*
+     * A cached pointer to FACS so that we don't have to look it up in interrupt
+     * contexts as we can't take mutexes.
+     */
+    struct acpi_facs *facs;
+
+    /*
+     * pm1{a,b}_evt_blk split into two registers for convenience
+     */
+    struct acpi_gas pm1a_status_blk;
+    struct acpi_gas pm1b_status_blk;
+    struct acpi_gas pm1a_enable_blk;
+    struct acpi_gas pm1b_enable_blk;
+
+#define UACPI_SLEEP_TYP_INVALID 0xFF
+    uacpi_u8 last_sleep_typ_a;
+    uacpi_u8 last_sleep_typ_b;
+
+    uacpi_u8 s0_sleep_typ_a;
+    uacpi_u8 s0_sleep_typ_b;
+
+    uacpi_bool global_lock_acquired;
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_bool was_in_legacy_mode;
+    uacpi_bool has_global_lock;
+    uacpi_bool sci_handle_valid;
+    uacpi_handle sci_handle;
+#endif
+    uacpi_u64 opcodes_executed;
+
+    uacpi_u32 loop_timeout_seconds;
+    uacpi_u32 max_call_stack_depth;
+
+    uacpi_u32 global_lock_seq_num;
+
+    /*
+     * These are stored here to protect against stuff like:
+     * - CopyObject(JUNK, \)
+     * - CopyObject(JUNK, \_GL)
+     */
+    uacpi_mutex *global_lock_mutex;
+    uacpi_object *root_object;
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_handle *global_lock_event;
+    uacpi_handle *global_lock_spinlock;
+    uacpi_bool global_lock_pending;
+#endif
+
+    uacpi_bool bad_timesource;
+    uacpi_u8 init_level;
+#endif // !UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+    uacpi_bool is_hardware_reduced;
+#endif
+
+    /*
+     * This is a per-table value but we mimic the NT implementation:
+     * treat all other definition blocks as if they were the same revision
+     * as DSDT.
+     */
+    uacpi_bool is_rev1;
+
+    uacpi_u8 log_level;
+};
+
+extern struct uacpi_runtime_context g_uacpi_rt_ctx;
+
+static inline uacpi_bool uacpi_check_flag(uacpi_u64 flag)
+{
+    return (g_uacpi_rt_ctx.flags & flag) == flag;
+}
+
+static inline uacpi_bool uacpi_should_log(enum uacpi_log_level lvl)
+{
+    return lvl <= g_uacpi_rt_ctx.log_level;
+}
+
+static inline uacpi_bool uacpi_is_hardware_reduced(void)
+{
+#ifndef UACPI_REDUCED_HARDWARE
+    return g_uacpi_rt_ctx.is_hardware_reduced;
+#else
+    return UACPI_TRUE;
+#endif
+}
+
+#ifndef UACPI_BAREBONES_MODE
+
+static inline const uacpi_char *uacpi_init_level_to_string(uacpi_u8 lvl)
+{
+    switch (lvl) {
+    case UACPI_INIT_LEVEL_EARLY:
+        return "early";
+    case UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED:
+        return "subsystem initialized";
+    case UACPI_INIT_LEVEL_NAMESPACE_LOADED:
+        return "namespace loaded";
+    case UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED:
+        return "namespace initialized";
+    default:
+        return "<invalid>";
+    }
+}
+
+#define UACPI_ENSURE_INIT_LEVEL_AT_LEAST(lvl)                               \
+    do {                                                                    \
+        if (uacpi_unlikely(g_uacpi_rt_ctx.init_level < lvl)) {              \
+            uacpi_error(                                                    \
+                "while evaluating %s: init level %d (%s) is too low, "      \
+                "expected at least %d (%s)\n", __FUNCTION__,                \
+                g_uacpi_rt_ctx.init_level,                                  \
+                uacpi_init_level_to_string(g_uacpi_rt_ctx.init_level), lvl, \
+                uacpi_init_level_to_string(lvl)                             \
+            );                                                              \
+            return UACPI_STATUS_INIT_LEVEL_MISMATCH;                        \
+        }                                                                   \
+    } while (0)
+
+#define UACPI_ENSURE_INIT_LEVEL_IS(lvl)                                     \
+    do {                                                                    \
+        if (uacpi_unlikely(g_uacpi_rt_ctx.init_level != lvl)) {             \
+            uacpi_error(                                                    \
+                "while evaluating %s: invalid init level %d (%s), "         \
+                "expected %d (%s)\n", __FUNCTION__,                         \
+                g_uacpi_rt_ctx.init_level,                                  \
+                uacpi_init_level_to_string(g_uacpi_rt_ctx.init_level), lvl, \
+                uacpi_init_level_to_string(lvl)                             \
+            );                                                              \
+            return UACPI_STATUS_INIT_LEVEL_MISMATCH;                        \
+        }                                                                   \
+    } while (0)
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/dynamic_array.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/kernel_api.h>
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE(name, type, inline_capacity)       \
+    struct name {                                                            \
+        type inline_storage[inline_capacity];                                \
+        type *dynamic_storage;                                               \
+        uacpi_size dynamic_capacity;                                         \
+        uacpi_size size_including_inline;                                    \
+    };                                                                       \
+
+#define DYNAMIC_ARRAY_SIZE(arr) ((arr)->size_including_inline)
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE_EXPORTS(name, type, prefix) \
+    prefix uacpi_size name##_inline_capacity(struct name *arr);       \
+    prefix type *name##_at(struct name *arr, uacpi_size idx);         \
+    prefix type *name##_alloc(struct name *arr);                      \
+    prefix type *name##_calloc(struct name *arr);                     \
+    prefix void name##_pop(struct name *arr);                         \
+    prefix uacpi_size name##_size(struct name *arr);                  \
+    prefix type *name##_last(struct name *arr)                        \
+    prefix void name##_clear(struct name *arr);
+
+#ifndef UACPI_BAREBONES_MODE
+#define DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_alloc(struct name *arr)                              \
+    {                                                                        \
+        uacpi_size inline_cap;                                               \
+        type *out_ptr;                                                       \
+                                                                             \
+        inline_cap = name##_inline_capacity(arr);                            \
+                                                                             \
+        if (arr->size_including_inline >= inline_cap) {                      \
+            uacpi_size dynamic_size;                                         \
+                                                                             \
+            dynamic_size = arr->size_including_inline - inline_cap;          \
+            if (dynamic_size == arr->dynamic_capacity) {                     \
+                uacpi_size bytes, type_size;                                 \
+                void *new_buf;                                               \
+                                                                             \
+                type_size = sizeof(*arr->dynamic_storage);                   \
+                                                                             \
+                if (arr->dynamic_capacity == 0) {                            \
+                    bytes = type_size * inline_cap;                          \
+                } else {                                                     \
+                    bytes = (arr->dynamic_capacity / 2) * type_size;         \
+                    if (bytes == 0)                                          \
+                        bytes += type_size;                                  \
+                                                                             \
+                    bytes += arr->dynamic_capacity * type_size;              \
+                }                                                            \
+                                                                             \
+                new_buf = uacpi_kernel_alloc(bytes);                         \
+                if (uacpi_unlikely(new_buf == UACPI_NULL))                   \
+                    return UACPI_NULL;                                       \
+                                                                             \
+                arr->dynamic_capacity = bytes / type_size;                   \
+                                                                             \
+                if (arr->dynamic_storage) {                                  \
+                    uacpi_memcpy(new_buf, arr->dynamic_storage,              \
+                                 dynamic_size * type_size);                  \
+                }                                                            \
+                uacpi_free(arr->dynamic_storage, dynamic_size * type_size);  \
+                arr->dynamic_storage = new_buf;                              \
+            }                                                                \
+                                                                             \
+            out_ptr = &arr->dynamic_storage[dynamic_size];                   \
+            goto ret;                                                        \
+        }                                                                    \
+        out_ptr = &arr->inline_storage[arr->size_including_inline];          \
+    ret:                                                                     \
+        arr->size_including_inline++;                                        \
+        return out_ptr;                                                      \
+    }
+
+#define DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)                           \
+    prefix void name##_clear(struct name *arr)                               \
+    {                                                                        \
+        uacpi_free(                                                          \
+            arr->dynamic_storage,                                            \
+            arr->dynamic_capacity * sizeof(*arr->dynamic_storage)            \
+        );                                                                   \
+        arr->size_including_inline = 0;                                      \
+        arr->dynamic_capacity = 0;                                           \
+        arr->dynamic_storage = UACPI_NULL;                                   \
+    }
+#else
+#define DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_alloc(struct name *arr)                              \
+    {                                                                        \
+        uacpi_size inline_cap;                                               \
+        type *out_ptr;                                                       \
+                                                                             \
+        inline_cap = name##_inline_capacity(arr);                            \
+                                                                             \
+        if (arr->size_including_inline >= inline_cap) {                      \
+            uacpi_size dynamic_size;                                         \
+                                                                             \
+            dynamic_size = arr->size_including_inline - inline_cap;          \
+            if (uacpi_unlikely(dynamic_size == arr->dynamic_capacity))       \
+                return UACPI_NULL;                                           \
+                                                                             \
+            out_ptr = &arr->dynamic_storage[dynamic_size];                   \
+            goto ret;                                                        \
+        }                                                                    \
+        out_ptr = &arr->inline_storage[arr->size_including_inline];          \
+    ret:                                                                     \
+        arr->size_including_inline++;                                        \
+        return out_ptr;                                                      \
+    }
+
+#define DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)                           \
+    prefix void name##_clear(struct name *arr)                               \
+    {                                                                        \
+        arr->size_including_inline = 0;                                      \
+        arr->dynamic_capacity = 0;                                           \
+        arr->dynamic_storage = UACPI_NULL;                                   \
+    }
+#endif
+
+#define DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(name, type, prefix)           \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_inline_capacity(struct name *arr)               \
+    {                                                                        \
+        return sizeof(arr->inline_storage) / sizeof(arr->inline_storage[0]); \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_capacity(struct name *arr)                      \
+    {                                                                        \
+        return name##_inline_capacity(arr) + arr->dynamic_capacity;          \
+    }                                                                        \
+                                                                             \
+    prefix type *name##_at(struct name *arr, uacpi_size idx)                 \
+    {                                                                        \
+        if (idx >= arr->size_including_inline)                               \
+            return UACPI_NULL;                                               \
+                                                                             \
+        if (idx < name##_inline_capacity(arr))                               \
+            return &arr->inline_storage[idx];                                \
+                                                                             \
+        return &arr->dynamic_storage[idx - name##_inline_capacity(arr)];     \
+    }                                                                        \
+                                                                             \
+    DYNAMIC_ARRAY_ALLOC_FN(name, type, prefix)                               \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_calloc(struct name *arr)                             \
+    {                                                                        \
+        type *ret;                                                           \
+                                                                             \
+        ret = name##_alloc(arr);                                             \
+        if (ret)                                                             \
+            uacpi_memzero(ret, sizeof(*ret));                                \
+                                                                             \
+        return ret;                                                          \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix void name##_pop(struct name *arr)                                 \
+    {                                                                        \
+        if (arr->size_including_inline == 0)                                 \
+            return;                                                          \
+                                                                             \
+        arr->size_including_inline--;                                        \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix uacpi_size name##_size(struct name *arr)                          \
+    {                                                                        \
+        return arr->size_including_inline;                                   \
+    }                                                                        \
+                                                                             \
+    UACPI_MAYBE_UNUSED                                                       \
+    prefix type *name##_last(struct name *arr)                               \
+    {                                                                        \
+        return name##_at(arr, arr->size_including_inline - 1);               \
+    }                                                                        \
+                                                                             \
+    DYNAMIC_ARRAY_CLEAR_FN(name, type, prefix)

drivers/bus/acpi_new/uacpi/include/uacpi/internal/event.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <uacpi/event.h>
+
+// This fixed event is internal-only, and we don't expose it in the enum
+#define UACPI_FIXED_EVENT_GLOBAL_LOCK 0
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_initialize_events_early(void)
+)
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_initialize_events(void)
+)
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_deinitialize_events(void)
+)
+
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_events_match_post_dynamic_table_load(void)
+)
+
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_clear_all_events(void)
+)

drivers/bus/acpi_new/uacpi/include/uacpi/internal/helpers.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <uacpi/helpers.h>
+
+#define UACPI_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+#define UACPI_UNUSED(x) (void)(x)

drivers/bus/acpi_new/uacpi/include/uacpi/internal/interpreter.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/internal/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+enum uacpi_table_load_cause {
+    UACPI_TABLE_LOAD_CAUSE_LOAD_OP,
+    UACPI_TABLE_LOAD_CAUSE_LOAD_TABLE_OP,
+    UACPI_TABLE_LOAD_CAUSE_INIT,
+    UACPI_TABLE_LOAD_CAUSE_HOST,
+};
+
+uacpi_status uacpi_execute_table(void*, enum uacpi_table_load_cause cause);
+uacpi_status uacpi_osi(uacpi_handle handle, uacpi_object *retval);
+
+uacpi_status uacpi_execute_control_method(
+    uacpi_namespace_node *scope, uacpi_control_method *method,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/io.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/acpi.h>
+#include <uacpi/io.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef struct uacpi_mapped_gas {
+    uacpi_handle mapping;
+    uacpi_u8 access_bit_width;
+    uacpi_u8 total_bit_width;
+    uacpi_u8 bit_offset;
+
+    uacpi_status (*read)(
+        uacpi_handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+    );
+    uacpi_status (*write)(
+        uacpi_handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+    );
+
+    void (*unmap)(uacpi_handle, uacpi_size);
+} uacpi_mapped_gas;
+
+uacpi_status uacpi_map_gas_noalloc(
+    const struct acpi_gas *gas, uacpi_mapped_gas *out_mapped
+);
+void uacpi_unmap_gas_nofree(uacpi_mapped_gas *gas);
+
+uacpi_size uacpi_round_up_bits_to_bytes(uacpi_size bit_length);
+
+void uacpi_read_buffer_field(
+    const uacpi_buffer_field *field, void *dst
+);
+void uacpi_write_buffer_field(
+    uacpi_buffer_field *field, const void *src, uacpi_size size
+);
+
+uacpi_status uacpi_field_unit_get_read_type(
+    struct uacpi_field_unit *field, uacpi_object_type *out_type
+);
+
+uacpi_status uacpi_field_unit_get_bit_length(
+    struct uacpi_field_unit *field, uacpi_size *out_length
+);
+
+uacpi_status uacpi_read_field_unit(
+    uacpi_field_unit *field, void *dst, uacpi_size size,
+    uacpi_data_view *wtr_response
+);
+uacpi_status uacpi_write_field_unit(
+    uacpi_field_unit *field, const void *src, uacpi_size size,
+    uacpi_data_view *wtr_response
+);
+
+uacpi_status uacpi_system_memory_read(
+    void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_system_memory_write(
+    void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+uacpi_status uacpi_system_io_read(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_system_io_write(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+uacpi_status uacpi_pci_read(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+);
+uacpi_status uacpi_pci_write(
+    uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/log.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <uacpi/kernel_api.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/log.h>
+
+#ifdef UACPI_FORMATTED_LOGGING
+#define uacpi_log uacpi_kernel_log
+#else
+UACPI_PRINTF_DECL(2, 3)
+void uacpi_log(uacpi_log_level, const uacpi_char*, ...);
+#endif
+
+#define uacpi_log_lvl(lvl, ...) \
+    do { if (uacpi_should_log(lvl)) uacpi_log(lvl, __VA_ARGS__); } while (0)
+
+#define uacpi_debug(...) uacpi_log_lvl(UACPI_LOG_DEBUG, __VA_ARGS__)
+#define uacpi_trace(...) uacpi_log_lvl(UACPI_LOG_TRACE, __VA_ARGS__)
+#define uacpi_info(...)  uacpi_log_lvl(UACPI_LOG_INFO, __VA_ARGS__)
+#define uacpi_warn(...)  uacpi_log_lvl(UACPI_LOG_WARN, __VA_ARGS__)
+#define uacpi_error(...) uacpi_log_lvl(UACPI_LOG_ERROR, __VA_ARGS__)
+
+void uacpi_logger_initialize(void);

drivers/bus/acpi_new/uacpi/include/uacpi/internal/mutex.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/kernel_api.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_bool uacpi_this_thread_owns_aml_mutex(uacpi_mutex*);
+
+uacpi_status uacpi_acquire_aml_mutex(uacpi_mutex*, uacpi_u16 timeout);
+uacpi_status uacpi_release_aml_mutex(uacpi_mutex*);
+
+static inline uacpi_status uacpi_acquire_native_mutex(uacpi_handle mtx)
+{
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    return uacpi_kernel_acquire_mutex(mtx, 0xFFFF);
+}
+
+uacpi_status uacpi_acquire_native_mutex_with_timeout(
+    uacpi_handle mtx, uacpi_u16 timeout
+);
+
+static inline uacpi_status uacpi_release_native_mutex(uacpi_handle mtx)
+{
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    uacpi_kernel_release_mutex(mtx);
+    return UACPI_STATUS_OK;
+}
+
+static inline uacpi_status uacpi_acquire_native_mutex_may_be_null(
+    uacpi_handle mtx
+)
+{
+    if (mtx == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    return uacpi_kernel_acquire_mutex(mtx, 0xFFFF);
+}
+
+static inline uacpi_status uacpi_release_native_mutex_may_be_null(
+    uacpi_handle mtx
+)
+{
+    if (mtx == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    uacpi_kernel_release_mutex(mtx);
+    return UACPI_STATUS_OK;
+}
+
+struct uacpi_recursive_lock {
+    uacpi_handle mutex;
+    uacpi_size depth;
+    uacpi_thread_id owner;
+};
+
+uacpi_status uacpi_recursive_lock_init(struct uacpi_recursive_lock *lock);
+uacpi_status uacpi_recursive_lock_deinit(struct uacpi_recursive_lock *lock);
+
+uacpi_status uacpi_recursive_lock_acquire(struct uacpi_recursive_lock *lock);
+uacpi_status uacpi_recursive_lock_release(struct uacpi_recursive_lock *lock);
+
+struct uacpi_rw_lock {
+    uacpi_handle read_mutex;
+    uacpi_handle write_mutex;
+    uacpi_size num_readers;
+};
+
+uacpi_status uacpi_rw_lock_init(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_lock_deinit(struct uacpi_rw_lock *lock);
+
+uacpi_status uacpi_rw_lock_read(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_unlock_read(struct uacpi_rw_lock *lock);
+
+uacpi_status uacpi_rw_lock_write(struct uacpi_rw_lock *lock);
+uacpi_status uacpi_rw_unlock_write(struct uacpi_rw_lock *lock);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/namespace.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/status.h>
+#include <uacpi/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define UACPI_NAMESPACE_NODE_FLAG_ALIAS (1 << 0)
+
+/*
+ * This node has been uninstalled and has no object associated with it.
+ *
+ * This is used to handle edge cases where an object needs to reference
+ * a namespace node, where the node might end up going out of scope before
+ * the object lifetime ends.
+ */
+#define UACPI_NAMESPACE_NODE_FLAG_DANGLING (1u << 1)
+
+/*
+ * This node is method-local and must not be exposed via public API as its
+ * lifetime is limited.
+ */
+#define UACPI_NAMESPACE_NODE_FLAG_TEMPORARY (1u << 2)
+
+#define UACPI_NAMESPACE_NODE_PREDEFINED (1u << 31)
+
+typedef struct uacpi_namespace_node {
+    struct uacpi_shareable shareable;
+    uacpi_object_name name;
+    uacpi_u32 flags;
+    uacpi_object *object;
+    struct uacpi_namespace_node *parent;
+    struct uacpi_namespace_node *child;
+    struct uacpi_namespace_node *next;
+} uacpi_namespace_node;
+
+uacpi_status uacpi_initialize_namespace(void);
+void uacpi_deinitialize_namespace(void);
+
+uacpi_namespace_node *uacpi_namespace_node_alloc(uacpi_object_name name);
+void uacpi_namespace_node_unref(uacpi_namespace_node *node);
+
+
+uacpi_status uacpi_namespace_node_type_unlocked(
+    const uacpi_namespace_node *node, uacpi_object_type *out_type
+);
+uacpi_status uacpi_namespace_node_is_one_of_unlocked(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+    uacpi_bool *out
+);
+
+uacpi_object *uacpi_namespace_node_get_object(const uacpi_namespace_node *node);
+
+uacpi_object *uacpi_namespace_node_get_object_typed(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask
+);
+
+uacpi_status uacpi_namespace_node_acquire_object(
+    const uacpi_namespace_node *node, uacpi_object **out_obj
+);
+uacpi_status uacpi_namespace_node_acquire_object_typed(
+    const uacpi_namespace_node *node, uacpi_object_type_bits,
+    uacpi_object **out_obj
+);
+
+uacpi_status uacpi_namespace_node_reacquire_object(
+    uacpi_object *obj
+);
+uacpi_status uacpi_namespace_node_release_object(
+    uacpi_object *obj
+);
+
+uacpi_status uacpi_namespace_node_install(
+    uacpi_namespace_node *parent, uacpi_namespace_node *node
+);
+uacpi_status uacpi_namespace_node_uninstall(uacpi_namespace_node *node);
+
+uacpi_namespace_node *uacpi_namespace_node_find_sub_node(
+    uacpi_namespace_node *parent,
+    uacpi_object_name name
+);
+
+enum uacpi_may_search_above_parent {
+    UACPI_MAY_SEARCH_ABOVE_PARENT_NO,
+    UACPI_MAY_SEARCH_ABOVE_PARENT_YES,
+};
+
+enum uacpi_permanent_only {
+    UACPI_PERMANENT_ONLY_NO,
+    UACPI_PERMANENT_ONLY_YES,
+};
+
+enum uacpi_should_lock {
+    UACPI_SHOULD_LOCK_NO,
+    UACPI_SHOULD_LOCK_YES,
+};
+
+uacpi_status uacpi_namespace_node_resolve(
+    uacpi_namespace_node *scope, const uacpi_char *path, enum uacpi_should_lock,
+    enum uacpi_may_search_above_parent, enum uacpi_permanent_only,
+    uacpi_namespace_node **out_node
+);
+
+uacpi_status uacpi_namespace_do_for_each_child(
+    uacpi_namespace_node *parent, uacpi_iteration_callback descending_callback,
+    uacpi_iteration_callback ascending_callback,
+    uacpi_object_type_bits, uacpi_u32 max_depth, enum uacpi_should_lock,
+    enum uacpi_permanent_only, void *user
+);
+
+uacpi_bool uacpi_namespace_node_is_dangling(uacpi_namespace_node *node);
+uacpi_bool uacpi_namespace_node_is_temporary(uacpi_namespace_node *node);
+uacpi_bool uacpi_namespace_node_is_predefined(uacpi_namespace_node *node);
+
+uacpi_status uacpi_namespace_read_lock(void);
+uacpi_status uacpi_namespace_read_unlock(void);
+
+uacpi_status uacpi_namespace_write_lock(void);
+uacpi_status uacpi_namespace_write_unlock(void);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/notify.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/notify.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_initialize_notify(void);
+void uacpi_deinitialize_notify(void);
+
+uacpi_status uacpi_notify_all(uacpi_namespace_node *node, uacpi_u64 value);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/opregion.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/opregion.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_initialize_opregion(void);
+void uacpi_deinitialize_opregion(void);
+
+void uacpi_trace_region_error(
+    uacpi_namespace_node *node, uacpi_char *message, uacpi_status ret
+);
+
+uacpi_status uacpi_install_address_space_handler_with_flags(
+    uacpi_namespace_node *device_node, enum uacpi_address_space space,
+    uacpi_region_handler handler, uacpi_handle handler_context,
+    uacpi_u16 flags
+);
+
+void uacpi_opregion_uninstall_handler(uacpi_namespace_node *node);
+
+uacpi_bool uacpi_address_space_handler_is_default(
+    uacpi_address_space_handler *handler
+);
+
+uacpi_address_space_handlers *uacpi_node_get_address_space_handlers(
+    uacpi_namespace_node *node
+);
+
+uacpi_status uacpi_initialize_opregion_node(uacpi_namespace_node *node);
+
+uacpi_status uacpi_opregion_attach(uacpi_namespace_node *node);
+
+void uacpi_install_default_address_space_handlers(void);
+
+uacpi_bool uacpi_is_buffer_access_address_space(uacpi_address_space space);
+
+union uacpi_opregion_io_data {
+    uacpi_u64 *integer;
+    uacpi_data_view buffer;
+};
+
+uacpi_status uacpi_dispatch_opregion_io(
+    uacpi_field_unit *field, uacpi_u32 offset,
+    uacpi_region_op op, union uacpi_opregion_io_data data
+);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/osi.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <uacpi/osi.h>
+
+uacpi_status uacpi_initialize_interfaces(void);
+void uacpi_deinitialize_interfaces(void);
+
+uacpi_status uacpi_handle_osi(const uacpi_char *string, uacpi_bool *out_value);

drivers/bus/acpi_new/uacpi/include/uacpi/internal/registers.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/registers.h>
+
+uacpi_status uacpi_initialize_registers(void);
+void uacpi_deinitialize_registers(void);

drivers/bus/acpi_new/uacpi/include/uacpi/internal/resources.h

@@ -0,0 +1,327 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/resources.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+enum uacpi_aml_resource {
+    UACPI_AML_RESOURCE_TYPE_INVALID = 0,
+
+    // Small resources
+    UACPI_AML_RESOURCE_IRQ,
+    UACPI_AML_RESOURCE_DMA,
+    UACPI_AML_RESOURCE_START_DEPENDENT,
+    UACPI_AML_RESOURCE_END_DEPENDENT,
+    UACPI_AML_RESOURCE_IO,
+    UACPI_AML_RESOURCE_FIXED_IO,
+    UACPI_AML_RESOURCE_FIXED_DMA,
+    UACPI_AML_RESOURCE_VENDOR_TYPE0,
+    UACPI_AML_RESOURCE_END_TAG,
+
+    // Large resources
+    UACPI_AML_RESOURCE_MEMORY24,
+    UACPI_AML_RESOURCE_GENERIC_REGISTER,
+    UACPI_AML_RESOURCE_VENDOR_TYPE1,
+    UACPI_AML_RESOURCE_MEMORY32,
+    UACPI_AML_RESOURCE_FIXED_MEMORY32,
+    UACPI_AML_RESOURCE_ADDRESS32,
+    UACPI_AML_RESOURCE_ADDRESS16,
+    UACPI_AML_RESOURCE_EXTENDED_IRQ,
+    UACPI_AML_RESOURCE_ADDRESS64,
+    UACPI_AML_RESOURCE_ADDRESS64_EXTENDED,
+    UACPI_AML_RESOURCE_GPIO_CONNECTION,
+    UACPI_AML_RESOURCE_PIN_FUNCTION,
+    UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+    UACPI_AML_RESOURCE_PIN_CONFIGURATION,
+    UACPI_AML_RESOURCE_PIN_GROUP,
+    UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION,
+    UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION,
+    UACPI_AML_RESOURCE_CLOCK_INPUT,
+    UACPI_AML_RESOURCE_MAX = UACPI_AML_RESOURCE_CLOCK_INPUT,
+};
+
+enum uacpi_aml_resource_size_kind {
+    UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+    UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS,
+    UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+};
+
+enum uacpi_aml_resource_kind {
+    UACPI_AML_RESOURCE_KIND_SMALL = 0,
+    UACPI_AML_RESOURCE_KIND_LARGE,
+};
+
+enum uacpi_resource_convert_opcode {
+    UACPI_RESOURCE_CONVERT_OPCODE_END = 0,
+
+    /*
+     * AML -> native:
+     * Take the mask at 'aml_offset' and convert to an array of uacpi_u8
+     * at 'native_offset' with the value corresponding to the bit index.
+     * The array size is written to the byte at offset 'arg2'.
+     *
+     * native -> AML:
+     * Walk each element of the array at 'native_offset' and set the
+     * corresponding bit in the mask at 'aml_offset' to 1. The array size is
+     * read from the byte at offset 'arg2'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8,
+    UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16,
+
+    /*
+     * AML -> native:
+     * Grab the bits at the byte at 'aml_offset' + 'bit_index', and copy its
+     * value into the byte at 'native_offset'.
+     *
+     * native -> AML:
+     * Grab first N bits at 'native_offset' and copy to 'aml_offset' starting
+     * at the 'bit_index'.
+     *
+     * NOTE:
+     * These must be contiguous in this order.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3,
+    UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6 =
+        UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3 + 3,
+
+    /*
+     * AML -> native:
+     * Copy N bytes at 'aml_offset' to 'native_offset'.
+     *
+     * native -> AML:
+     * Copy N bytes at 'native_offset' to 'aml_offset'.
+     *
+     * 'imm' is added to the accumulator.
+     *
+     * NOTE: These are affected by the current value in the accumulator. If it's
+     *       set to 0 at the time of evalution, this is executed once, N times
+     *       otherwise. 0xFF is considered a special value, which resets the
+     *       accumulator to 0 unconditionally.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_8,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_16,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_32,
+    UACPI_RESOURCE_CONVERT_OPCODE_FIELD_64,
+
+    /*
+     * If the length of the current resource is less than 'arg0', then skip
+     * 'imm' instructions.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_AML_SIZE_LESS_THAN,
+
+    /*
+     * Skip 'imm' instructions if 'arg0' is not equal to the value in the
+     * accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_NOT_EQUALS,
+
+    /*
+     * AML -> native:
+     * Set the byte at 'native_offset' to 'imm'.
+     *
+     * native -> AML:
+     * Set the byte at 'aml_offset' to 'imm'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SET_TO_IMM,
+
+    /*
+     * AML -> native:
+     * Load the AML resoruce length into the accumulator as well as the field at
+     * 'native_offset' of width N.
+     *
+     * native -> AML:
+     * Load the resource length into the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32,
+
+    /*
+     * AML -> native:
+     * Load the 8 bit field at 'aml_offset' into the accumulator and store at
+     * 'native_offset'.
+     *
+     * native -> AML:
+     * Load the 8 bit field at 'native_offset' into the accumulator and store
+     * at 'aml_offset'.
+     *
+     * The accumulator is multiplied by 'imm' unless it's set to zero.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_STORE,
+
+    /*
+     * Load the N bit field at 'native_offset' into the accumulator
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_NATIVE,
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_16_NATIVE,
+
+    /*
+     * Load 'imm' into the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_IMM,
+
+    /*
+     * AML -> native:
+     * Load the resource source at offset = aml size + accumulator into the
+     * uacpi_resource_source struct at 'native_offset'. The string bytes are
+     * written to the offset at resource size + accumulator. The presence is
+     * detected by comparing the length of the resource to the offset,
+     * 'arg2' optionally specifies the offset to the upper bound of the string.
+     *
+     * native -> AML:
+     * Load the resource source from the uacpi_resource_source struct at
+     * 'native_offset' to aml_size + accumulator. aml_size + accumulator is
+     * optionally written to 'aml_offset' if it's specified.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE,
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX,
+    UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL,
+
+    /*
+     * AML -> native:
+     * Load the pin table with upper bound specified at 'aml_offset'.
+     * The table length is calculated by subtracting the upper bound from
+     * aml_size and is written into the accumulator.
+     *
+     * native -> AML:
+     * Load the pin table length from 'native_offset' and multiply by 2, store
+     * the result in the accumulator.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH,
+
+    /*
+     * AML -> native:
+     * Store the accumulator divided by 2 at 'native_offset'.
+     * The table is copied to the offset at resource size from offset at
+     * aml_size with the pointer written to the offset at 'arg2'.
+     *
+     * native -> AML:
+     * Read the pin table from resource size offset, write aml_size to
+     * 'aml_offset'. Copy accumulator bytes to the offset at aml_size.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE,
+
+    /*
+     * AML -> native:
+     * Load vendor data with offset stored at 'aml_offset'. The length is
+     * calculated as aml_size - aml_offset and is written to 'native_offset'.
+     * The data is written to offset - aml_size with the pointer written back
+     * to the offset at 'arg2'.
+     *
+     * native -> AML:
+     * Read vendor data from the pointer at offset 'arg2' and size at
+     * 'native_offset', the offset to write to is calculated as the difference
+     * between the data pointer and the native resource end pointer.
+     * offset + aml_size is written to 'aml_offset' and the data is copied
+     * there as well.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA,
+
+    /*
+     * AML -> native:
+     * Read the serial type from the byte at 'aml_offset' and write it to the
+     * type field of the uacpi_resource_serial_bus_common structure. Convert
+     * the serial type to native and set the resource type to it. Copy the
+     * vendor data to the offset at native size, the length is calculated
+     * as type_data_length - extra-type-specific-size, and is written to
+     * vendor_data_length, as well as the accumulator. The data pointer is
+     * written to vendor_data.
+     *
+     * native -> AML:
+     * Set the serial type at 'aml_offset' to the value stored at
+     * 'native_offset'. Load the vendor data to the offset at aml_size,
+     * the length is read from 'vendor_data_length', and the data is copied from
+     * 'vendor_data'.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC,
+
+    /*
+     * Produces an error if encountered in the instruction stream.
+     * Used to trap invalid/unexpected code flow.
+     */
+    UACPI_RESOURCE_CONVERT_OPCODE_UNREACHABLE,
+};
+
+struct uacpi_resource_convert_instruction {
+    uacpi_u8 code;
+
+    union {
+        uacpi_u8 aml_offset;
+        uacpi_u8 arg0;
+    };
+
+    union {
+        uacpi_u8 native_offset;
+        uacpi_u8 arg1;
+    };
+
+    union {
+        uacpi_u8 imm;
+        uacpi_u8 bit_index;
+        uacpi_u8 arg2;
+    };
+};
+
+struct uacpi_resource_spec {
+    uacpi_u8 type : 5;
+    uacpi_u8 native_type : 5;
+    uacpi_u8 resource_kind : 1;
+    uacpi_u8 size_kind : 2;
+
+    /*
+     * Size of the resource as appears in the AML byte stream, for variable
+     * length resources this is the minimum.
+     */
+    uacpi_u16 aml_size;
+
+    /*
+     * Size of the native human-readable uacpi resource, for variable length
+     * resources this is the minimum. The final length is this field plus the
+     * result of extra_size_for_native().
+     */
+    uacpi_u16 native_size;
+
+    /*
+     * Calculate the amount of extra bytes that must be allocated for a specific
+     * native resource given the AML counterpart. This being NULL means no extra
+     * bytes are needed, aka native resources is always the same size.
+     */
+    uacpi_size (*extra_size_for_native)(
+        const struct uacpi_resource_spec*, void*, uacpi_size
+    );
+
+    /*
+     * Calculate the number of bytes needed to represent a native resource as
+     * AML. The 'aml_size' field is used if this is NULL.
+     */
+    uacpi_size (*size_for_aml)(
+        const struct uacpi_resource_spec*, uacpi_resource*
+    );
+
+    const struct uacpi_resource_convert_instruction *to_native;
+    const struct uacpi_resource_convert_instruction *to_aml;
+};
+
+typedef uacpi_iteration_decision (*uacpi_aml_resource_iteration_callback)(
+    void*, uacpi_u8 *data, uacpi_u16 resource_size,
+    const struct uacpi_resource_spec*
+);
+
+uacpi_status uacpi_for_each_aml_resource(
+    uacpi_data_view, uacpi_aml_resource_iteration_callback cb, void *user
+);
+
+uacpi_status uacpi_find_aml_resource_end_tag(
+    uacpi_data_view, uacpi_size *out_offset
+);
+
+uacpi_status uacpi_native_resources_from_aml(
+    uacpi_data_view, uacpi_resources **out_resources
+);
+
+uacpi_status uacpi_native_resources_to_aml(
+    uacpi_resources *resources, uacpi_object **out_template
+);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/shareable.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+struct uacpi_shareable {
+    uacpi_u32 reference_count;
+};
+
+void uacpi_shareable_init(uacpi_handle);
+
+uacpi_bool uacpi_bugged_shareable(uacpi_handle);
+void uacpi_make_shareable_bugged(uacpi_handle);
+
+uacpi_u32 uacpi_shareable_ref(uacpi_handle);
+uacpi_u32 uacpi_shareable_unref(uacpi_handle);
+
+void uacpi_shareable_unref_and_delete_if_last(
+    uacpi_handle, void (*do_free)(uacpi_handle)
+);
+
+uacpi_u32 uacpi_shareable_refcount(uacpi_handle);

drivers/bus/acpi_new/uacpi/include/uacpi/internal/stdlib.h

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <uacpi/internal/types.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/platform/libc.h>
+#include <uacpi/platform/config.h>
+#include <uacpi/kernel_api.h>
+
+#ifdef UACPI_USE_BUILTIN_STRING
+
+#ifndef uacpi_memcpy
+void *uacpi_memcpy(void *dest, const void *src, uacpi_size count);
+#endif
+
+#ifndef uacpi_memmove
+void *uacpi_memmove(void *dest, const void *src, uacpi_size count);
+#endif
+
+#ifndef uacpi_memset
+void *uacpi_memset(void *dest, uacpi_i32 ch, uacpi_size count);
+#endif
+
+#ifndef uacpi_memcmp
+uacpi_i32 uacpi_memcmp(const void *lhs, const void *rhs, uacpi_size count);
+#endif
+
+#else
+
+#ifndef uacpi_memcpy
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMCPY
+        #define uacpi_memcpy __builtin_memcpy
+    #else
+        extern void *memcpy(void *dest, const void *src, uacpi_size count);
+        #define uacpi_memcpy memcpy
+    #endif
+#endif
+
+#ifndef uacpi_memmove
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMMOVE
+        #define uacpi_memmove __builtin_memmove
+    #else
+        extern void *memmove(void *dest, const void *src, uacpi_size count);
+        #define uacpi_memmove memmove
+    #endif
+#endif
+
+#ifndef uacpi_memset
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMSET
+        #define uacpi_memset __builtin_memset
+    #else
+        extern void *memset(void *dest, int ch, uacpi_size count);
+        #define uacpi_memset memset
+    #endif
+#endif
+
+#ifndef uacpi_memcmp
+    #ifdef UACPI_COMPILER_HAS_BUILTIN_MEMCMP
+        #define uacpi_memcmp __builtin_memcmp
+    #else
+        extern int memcmp(const void *lhs, const void *rhs, uacpi_size count);
+        #define uacpi_memcmp memcmp
+    #endif
+#endif
+
+#endif
+
+#ifndef uacpi_strlen
+uacpi_size uacpi_strlen(const uacpi_char *str);
+#endif
+
+#ifndef uacpi_strnlen
+uacpi_size uacpi_strnlen(const uacpi_char *str, uacpi_size max);
+#endif
+
+#ifndef uacpi_strcmp
+uacpi_i32 uacpi_strcmp(const uacpi_char *lhs, const uacpi_char *rhs);
+#endif
+
+#ifndef uacpi_snprintf
+UACPI_PRINTF_DECL(3, 4)
+uacpi_i32 uacpi_snprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, ...
+);
+#endif
+
+#ifndef uacpi_vsnprintf
+uacpi_i32 uacpi_vsnprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,
+    uacpi_va_list vlist
+);
+#endif
+
+#ifdef UACPI_SIZED_FREES
+#define uacpi_free(mem, size) uacpi_kernel_free(mem, size)
+#else
+#define uacpi_free(mem, _) uacpi_kernel_free(mem)
+#endif
+
+#define uacpi_memzero(ptr, size) uacpi_memset(ptr, 0, size)
+
+#define UACPI_COMPARE(x, y, op) ((x) op (y) ? (x) : (y))
+#define UACPI_MIN(x, y) UACPI_COMPARE(x, y, <)
+#define UACPI_MAX(x, y) UACPI_COMPARE(x, y, >)
+
+#define UACPI_ALIGN_UP_MASK(x, mask) (((x) + (mask)) & ~(mask))
+#define UACPI_ALIGN_UP(x, val, type) UACPI_ALIGN_UP_MASK(x, (type)(val) - 1)
+
+#define UACPI_ALIGN_DOWN_MASK(x, mask) ((x) & ~(mask))
+#define UACPI_ALIGN_DOWN(x, val, type) UACPI_ALIGN_DOWN_MASK(x, (type)(val) - 1)
+
+#define UACPI_IS_ALIGNED_MASK(x, mask) (((x) & (mask)) == 0)
+#define UACPI_IS_ALIGNED(x, val, type) UACPI_IS_ALIGNED_MASK(x, (type)(val) - 1)
+
+#define UACPI_IS_POWER_OF_TWO(x, type) UACPI_IS_ALIGNED(x, x, type)
+
+void uacpi_memcpy_zerout(void *dst, const void *src,
+                         uacpi_size dst_size, uacpi_size src_size);
+
+// Returns the one-based bit location of LSb or 0
+uacpi_u8 uacpi_bit_scan_forward(uacpi_u64);
+
+// Returns the one-based bit location of MSb or 0
+uacpi_u8 uacpi_bit_scan_backward(uacpi_u64);
+
+#ifndef UACPI_NATIVE_ALLOC_ZEROED
+void *uacpi_builtin_alloc_zeroed(uacpi_size size);
+#define uacpi_kernel_alloc_zeroed uacpi_builtin_alloc_zeroed
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/internal/tables.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/tables.h>
+
+enum uacpi_table_origin {
+#ifndef UACPI_BAREBONES_MODE
+    UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL = 0,
+#endif
+    UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL = 1,
+
+    UACPI_TABLE_ORIGIN_HOST_VIRTUAL,
+    UACPI_TABLE_ORIGIN_HOST_PHYSICAL,
+};
+
+struct uacpi_installed_table {
+    uacpi_phys_addr phys_addr;
+    struct acpi_sdt_hdr hdr;
+    void *ptr;
+
+    uacpi_u16 reference_count;
+
+#define UACPI_TABLE_LOADED (1 << 0)
+#define UACPI_TABLE_CSUM_VERIFIED (1 << 1)
+#define UACPI_TABLE_INVALID (1 << 2)
+    uacpi_u8 flags;
+    uacpi_u8 origin;
+};
+
+uacpi_status uacpi_initialize_tables(void);
+void uacpi_deinitialize_tables(void);
+
+uacpi_bool uacpi_signatures_match(const void *const lhs, const void *const rhs);
+uacpi_status uacpi_check_table_signature(void *table, const uacpi_char *expect);
+uacpi_status uacpi_verify_table_checksum(void *table, uacpi_size size);
+
+uacpi_status uacpi_table_install_physical_with_origin(
+    uacpi_phys_addr phys, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+uacpi_status uacpi_table_install_with_origin(
+    void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+
+#ifndef UACPI_BAREBONES_MODE
+void uacpi_table_mark_as_loaded(uacpi_size idx);
+
+uacpi_status uacpi_table_load_with_cause(
+    uacpi_size idx, enum uacpi_table_load_cause cause
+);
+#endif // !UACPI_BAREBONES_MODE
+
+typedef uacpi_iteration_decision (*uacpi_table_iteration_callback)
+    (void *user, struct uacpi_installed_table *tbl, uacpi_size idx);
+
+uacpi_status uacpi_for_each_table(
+    uacpi_size base_idx, uacpi_table_iteration_callback, void *user
+);
+
+typedef uacpi_bool (*uacpi_table_match_callback)
+    (struct uacpi_installed_table *tbl);
+
+uacpi_status uacpi_table_match(
+    uacpi_size base_idx, uacpi_table_match_callback, uacpi_table *out_table
+);
+
+#define UACPI_PRI_TBL_HDR "'%.4s' (OEM ID '%.6s' OEM Table ID '%.8s')"
+#define UACPI_FMT_TBL_HDR(hdr) (hdr)->signature, (hdr)->oemid, (hdr)->oem_table_id

drivers/bus/acpi_new/uacpi/include/uacpi/internal/types.h

@@ -0,0 +1,310 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/types.h>
+#include <uacpi/internal/shareable.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+// object->flags field if object->type == UACPI_OBJECT_REFERENCE
+enum uacpi_reference_kind {
+    UACPI_REFERENCE_KIND_REFOF = 0,
+    UACPI_REFERENCE_KIND_LOCAL = 1,
+    UACPI_REFERENCE_KIND_ARG = 2,
+    UACPI_REFERENCE_KIND_NAMED = 3,
+    UACPI_REFERENCE_KIND_PKG_INDEX = 4,
+};
+
+// object->flags field if object->type == UACPI_OBJECT_STRING
+enum uacpi_string_kind {
+    UACPI_STRING_KIND_NORMAL = 0,
+    UACPI_STRING_KIND_PATH,
+};
+
+typedef struct uacpi_buffer {
+    struct uacpi_shareable shareable;
+    union {
+        void *data;
+        uacpi_u8 *byte_data;
+        uacpi_char *text;
+    };
+    uacpi_size size;
+} uacpi_buffer;
+
+typedef struct uacpi_package {
+    struct uacpi_shareable shareable;
+    uacpi_object **objects;
+    uacpi_size count;
+} uacpi_package;
+
+typedef struct uacpi_buffer_field {
+    uacpi_buffer *backing;
+    uacpi_size bit_index;
+    uacpi_u32 bit_length;
+    uacpi_bool force_buffer;
+} uacpi_buffer_field;
+
+typedef struct uacpi_buffer_index {
+    uacpi_size idx;
+    uacpi_buffer *buffer;
+} uacpi_buffer_index;
+
+typedef struct uacpi_mutex {
+    struct uacpi_shareable shareable;
+    uacpi_handle handle;
+    uacpi_thread_id owner;
+    uacpi_u16 depth;
+    uacpi_u8 sync_level;
+} uacpi_mutex;
+
+typedef struct uacpi_event {
+    struct uacpi_shareable shareable;
+    uacpi_handle handle;
+} uacpi_event;
+
+typedef struct uacpi_address_space_handler {
+    struct uacpi_shareable shareable;
+    uacpi_region_handler callback;
+    uacpi_handle user_context;
+    struct uacpi_address_space_handler *next;
+    struct uacpi_operation_region *regions;
+    uacpi_u16 space;
+
+#define UACPI_ADDRESS_SPACE_HANDLER_DEFAULT (1 << 0)
+    uacpi_u16 flags;
+} uacpi_address_space_handler;
+
+/*
+ * NOTE: These are common object headers.
+ * Any changes to these structs must be propagated to all objects.
+ * ==============================================================
+ * Common for the following objects:
+ * - UACPI_OBJECT_OPERATION_REGION
+ * - UACPI_OBJECT_PROCESSOR
+ * - UACPI_OBJECT_DEVICE
+ * - UACPI_OBJECT_THERMAL_ZONE
+ */
+typedef struct uacpi_address_space_handlers {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *head;
+} uacpi_address_space_handlers;
+
+typedef struct uacpi_device_notify_handler {
+    uacpi_notify_handler callback;
+    uacpi_handle user_context;
+    struct uacpi_device_notify_handler *next;
+} uacpi_device_notify_handler;
+
+/*
+ * Common for the following objects:
+ * - UACPI_OBJECT_PROCESSOR
+ * - UACPI_OBJECT_DEVICE
+ * - UACPI_OBJECT_THERMAL_ZONE
+ */
+typedef struct uacpi_handlers {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_head;
+    uacpi_device_notify_handler *notify_head;
+} uacpi_handlers;
+
+// This region has a corresponding _REG method that was succesfully executed
+#define UACPI_OP_REGION_STATE_REG_EXECUTED (1 << 0)
+
+// This region was successfully attached to a handler
+#define UACPI_OP_REGION_STATE_ATTACHED (1 << 1)
+
+typedef struct uacpi_operation_region {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *handler;
+    uacpi_handle user_context;
+    uacpi_u16 space;
+    uacpi_u8 state_flags;
+    uacpi_u64 offset;
+    uacpi_u64 length;
+
+    union {
+        // If space == TABLE_DATA
+        uacpi_u64 table_idx;
+
+        // If space == PCC
+        uacpi_u8 *internal_buffer;
+    };
+
+    // Used to link regions sharing the same handler
+    struct uacpi_operation_region *next;
+} uacpi_operation_region;
+
+typedef struct uacpi_device {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+} uacpi_device;
+
+typedef struct uacpi_processor {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+    uacpi_u8 id;
+    uacpi_u32 block_address;
+    uacpi_u8 block_length;
+} uacpi_processor;
+
+typedef struct uacpi_thermal_zone {
+    struct uacpi_shareable shareable;
+    uacpi_address_space_handler *address_space_handlers;
+    uacpi_device_notify_handler *notify_handlers;
+} uacpi_thermal_zone;
+
+typedef struct uacpi_power_resource {
+    uacpi_u8 system_level;
+    uacpi_u16 resource_order;
+} uacpi_power_resource;
+
+typedef uacpi_status (*uacpi_native_call_handler)(
+    uacpi_handle ctx, uacpi_object *retval
+);
+
+typedef struct uacpi_control_method {
+    struct uacpi_shareable shareable;
+    union {
+        uacpi_u8 *code;
+        uacpi_native_call_handler handler;
+    };
+    uacpi_mutex *mutex;
+    uacpi_u32 size;
+    uacpi_u8 sync_level : 4;
+    uacpi_u8 args : 3;
+    uacpi_u8 is_serialized : 1;
+    uacpi_u8 named_objects_persist: 1;
+    uacpi_u8 native_call : 1;
+    uacpi_u8 owns_code : 1;
+} uacpi_control_method;
+
+typedef enum uacpi_access_type {
+    UACPI_ACCESS_TYPE_ANY = 0,
+    UACPI_ACCESS_TYPE_BYTE = 1,
+    UACPI_ACCESS_TYPE_WORD = 2,
+    UACPI_ACCESS_TYPE_DWORD = 3,
+    UACPI_ACCESS_TYPE_QWORD = 4,
+    UACPI_ACCESS_TYPE_BUFFER = 5,
+} uacpi_access_type;
+
+typedef enum uacpi_lock_rule {
+    UACPI_LOCK_RULE_NO_LOCK = 0,
+    UACPI_LOCK_RULE_LOCK = 1,
+} uacpi_lock_rule;
+
+typedef enum uacpi_update_rule {
+    UACPI_UPDATE_RULE_PRESERVE = 0,
+    UACPI_UPDATE_RULE_WRITE_AS_ONES = 1,
+    UACPI_UPDATE_RULE_WRITE_AS_ZEROES = 2,
+} uacpi_update_rule;
+
+typedef enum uacpi_field_unit_kind {
+    UACPI_FIELD_UNIT_KIND_NORMAL = 0,
+    UACPI_FIELD_UNIT_KIND_INDEX = 1,
+    UACPI_FIELD_UNIT_KIND_BANK = 2,
+} uacpi_field_unit_kind;
+
+typedef struct uacpi_field_unit {
+    struct uacpi_shareable shareable;
+
+    union {
+        // UACPI_FIELD_UNIT_KIND_NORMAL
+        struct {
+            uacpi_namespace_node *region;
+        };
+
+        // UACPI_FIELD_UNIT_KIND_INDEX
+        struct {
+            struct uacpi_field_unit *index;
+            struct uacpi_field_unit *data;
+        };
+
+        // UACPI_FIELD_UNIT_KIND_BANK
+        struct {
+            uacpi_namespace_node *bank_region;
+            struct uacpi_field_unit *bank_selection;
+            uacpi_u64 bank_value;
+        };
+    };
+
+    uacpi_object *connection;
+
+    uacpi_u32 byte_offset;
+    uacpi_u32 bit_length;
+    uacpi_u32 pin_offset;
+    uacpi_u8 bit_offset_within_first_byte;
+    uacpi_u8 access_width_bytes;
+    uacpi_u8 access_length;
+
+    uacpi_u8 attributes : 4;
+    uacpi_u8 update_rule : 2;
+    uacpi_u8 kind : 2;
+    uacpi_u8 lock_rule : 1;
+} uacpi_field_unit;
+
+typedef struct uacpi_object {
+    struct uacpi_shareable shareable;
+    uacpi_u8 type;
+    uacpi_u8 flags;
+
+    union {
+        uacpi_u64 integer;
+        uacpi_package *package;
+        uacpi_buffer_field buffer_field;
+        uacpi_object *inner_object;
+        uacpi_control_method *method;
+        uacpi_buffer *buffer;
+        uacpi_mutex *mutex;
+        uacpi_event *event;
+        uacpi_buffer_index buffer_index;
+        uacpi_operation_region *op_region;
+        uacpi_device *device;
+        uacpi_processor *processor;
+        uacpi_thermal_zone *thermal_zone;
+        uacpi_address_space_handlers *address_space_handlers;
+        uacpi_handlers *handlers;
+        uacpi_power_resource power_resource;
+        uacpi_field_unit *field_unit;
+    };
+} uacpi_object;
+
+uacpi_object *uacpi_create_object(uacpi_object_type type);
+
+enum uacpi_assign_behavior {
+    UACPI_ASSIGN_BEHAVIOR_DEEP_COPY,
+    UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY,
+};
+
+uacpi_status uacpi_object_assign(uacpi_object *dst, uacpi_object *src,
+                                 enum uacpi_assign_behavior);
+
+void uacpi_object_attach_child(uacpi_object *parent, uacpi_object *child);
+void uacpi_object_detach_child(uacpi_object *parent);
+
+struct uacpi_object *uacpi_create_internal_reference(
+    enum uacpi_reference_kind kind, uacpi_object *child
+);
+uacpi_object *uacpi_unwrap_internal_reference(uacpi_object *object);
+
+enum uacpi_prealloc_objects {
+    UACPI_PREALLOC_OBJECTS_NO,
+    UACPI_PREALLOC_OBJECTS_YES,
+};
+
+uacpi_bool uacpi_package_fill(
+    uacpi_package *pkg, uacpi_size num_elements,
+    enum uacpi_prealloc_objects prealloc_objects
+);
+
+uacpi_mutex *uacpi_create_mutex(void);
+void uacpi_mutex_unref(uacpi_mutex*);
+
+void uacpi_method_unref(uacpi_control_method*);
+
+void uacpi_address_space_handler_unref(uacpi_address_space_handler *handler);
+
+void uacpi_buffer_to_view(uacpi_buffer*, uacpi_data_view*);
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/include/uacpi/internal/utilities.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/utilities.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/stdlib.h>
+
+static inline uacpi_phys_addr uacpi_truncate_phys_addr_with_warn(uacpi_u64 large_addr)
+{
+    if (sizeof(uacpi_phys_addr) < 8 && large_addr > 0xFFFFFFFF) {
+        uacpi_warn(
+            "truncating a physical address 0x%"UACPI_PRIX64
+            " outside of address space\n", UACPI_FMT64(large_addr)
+        );
+    }
+
+    return (uacpi_phys_addr)large_addr;
+}
+
+#define UACPI_PTR_TO_VIRT_ADDR(ptr)   ((uacpi_virt_addr)(ptr))
+#define UACPI_VIRT_ADDR_TO_PTR(vaddr) ((void*)(vaddr))
+
+#define UACPI_PTR_ADD(ptr, value) ((void*)(((uacpi_u8*)(ptr)) + value))
+
+/*
+ * Target buffer must have a length of at least 8 bytes.
+ */
+void uacpi_eisa_id_to_string(uacpi_u32, uacpi_char *out_string);
+
+enum uacpi_base {
+    UACPI_BASE_AUTO,
+    UACPI_BASE_OCT = 8,
+    UACPI_BASE_DEC = 10,
+    UACPI_BASE_HEX = 16,
+};
+uacpi_status uacpi_string_to_integer(
+    const uacpi_char *str, uacpi_size max_chars, enum uacpi_base base,
+    uacpi_u64 *out_value
+);
+
+uacpi_bool uacpi_is_valid_nameseg(uacpi_u8 *nameseg);
+
+void uacpi_free_dynamic_string(const uacpi_char *str);
+
+#define UACPI_NANOSECONDS_PER_SEC (1000ull * 1000ull * 1000ull)

drivers/bus/acpi_new/uacpi/include/uacpi/io.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/acpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_gas_read(const struct acpi_gas *gas, uacpi_u64 *value);
+uacpi_status uacpi_gas_write(const struct acpi_gas *gas, uacpi_u64 value);
+
+typedef struct uacpi_mapped_gas uacpi_mapped_gas;
+
+/*
+ * Map a GAS for faster access in the future. The handle returned via
+ * 'out_mapped' must be freed & unmapped using uacpi_unmap_gas() when
+ * no longer needed.
+ */
+uacpi_status uacpi_map_gas(const struct acpi_gas *gas, uacpi_mapped_gas **out_mapped);
+void uacpi_unmap_gas(uacpi_mapped_gas*);
+
+/*
+ * Same as uacpi_gas_{read,write} but operates on a pre-mapped handle for faster
+ * access and/or ability to use in critical sections/irq contexts.
+ */
+uacpi_status uacpi_gas_read_mapped(const uacpi_mapped_gas *gas, uacpi_u64 *value);
+uacpi_status uacpi_gas_write_mapped(const uacpi_mapped_gas *gas, uacpi_u64 value);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/kernel_api.h

@@ -0,0 +1,375 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/platform/arch_helpers.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Returns the PHYSICAL address of the RSDP structure via *out_rsdp_address.
+uacpi_status uacpi_kernel_get_rsdp(uacpi_phys_addr *out_rsdp_address);
+
+/*
+ * Map a physical memory range starting at 'addr' with length 'len', and return
+ * a virtual address that can be used to access it.
+ *
+ * NOTE: 'addr' may be misaligned, in this case the host is expected to round it
+ *       down to the nearest page-aligned boundary and map that, while making
+ *       sure that at least 'len' bytes are still mapped starting at 'addr'. The
+ *       return value preserves the misaligned offset.
+ *
+ *       Example for uacpi_kernel_map(0x1ABC, 0xF00):
+ *           1. Round down the 'addr' we got to the nearest page boundary.
+ *              Considering a PAGE_SIZE of 4096 (or 0x1000), 0x1ABC rounded down
+ *              is 0x1000, offset within the page is 0x1ABC - 0x1000 => 0xABC
+ *           2. Requested 'len' is 0xF00 bytes, but we just rounded the address
+ *              down by 0xABC bytes, so add those on top. 0xF00 + 0xABC => 0x19BC
+ *           3. Round up the final 'len' to the nearest PAGE_SIZE boundary, in
+ *              this case 0x19BC is 0x2000 bytes (2 pages if PAGE_SIZE is 4096)
+ *           4. Call the VMM to map the aligned address 0x1000 (from step 1)
+ *              with length 0x2000 (from step 3). Let's assume the returned
+ *              virtual address for the mapping is 0xF000.
+ *           5. Add the original offset within page 0xABC (from step 1) to the
+ *              resulting virtual address 0xF000 + 0xABC => 0xFABC. Return it
+ *              to uACPI.
+ */
+void *uacpi_kernel_map(uacpi_phys_addr addr, uacpi_size len);
+
+/*
+ * Unmap a virtual memory range at 'addr' with a length of 'len' bytes.
+ *
+ * NOTE: 'addr' may be misaligned, see the comment above 'uacpi_kernel_map'.
+ *       Similar steps to uacpi_kernel_map can be taken to retrieve the
+ *       virtual address originally returned by the VMM for this mapping
+ *       as well as its true length.
+ */
+void uacpi_kernel_unmap(void *addr, uacpi_size len);
+
+#ifndef UACPI_FORMATTED_LOGGING
+void uacpi_kernel_log(uacpi_log_level, const uacpi_char*);
+#else
+UACPI_PRINTF_DECL(2, 3)
+void uacpi_kernel_log(uacpi_log_level, const uacpi_char*, ...);
+void uacpi_kernel_vlog(uacpi_log_level, const uacpi_char*, uacpi_va_list);
+#endif
+
+/*
+ * Only the above ^^^ API may be used by early table access and
+ * UACPI_BAREBONES_MODE.
+ */
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Convenience initialization/deinitialization hooks that will be called by
+ * uACPI automatically when appropriate if compiled-in.
+ */
+#ifdef UACPI_KERNEL_INITIALIZATION
+/*
+ * This API is invoked for each initialization level so that appropriate parts
+ * of the host kernel and/or glue code can be initialized at different stages.
+ *
+ * uACPI API that triggers calls to uacpi_kernel_initialize and the respective
+ * 'current_init_lvl' passed to the hook at that stage:
+ * 1. uacpi_initialize() -> UACPI_INIT_LEVEL_EARLY
+ * 2. uacpi_namespace_load() -> UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED
+ * 3. (start of) uacpi_namespace_initialize() -> UACPI_INIT_LEVEL_NAMESPACE_LOADED
+ * 4. (end of) uacpi_namespace_initialize() -> UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED
+ */
+uacpi_status uacpi_kernel_initialize(uacpi_init_level current_init_lvl);
+void uacpi_kernel_deinitialize(void);
+#endif
+
+/*
+ * Open a PCI device at 'address' for reading & writing.
+ *
+ * Note that this must be able to open any arbitrary PCI device, not just those
+ * detected during kernel PCI enumeration, since the following pattern is
+ * relatively common in AML firmware:
+ *    Device (THC0)
+ *    {
+ *        // Device at 00:10.06
+ *        Name (_ADR, 0x00100006)  // _ADR: Address
+ *
+ *        OperationRegion (THCR, PCI_Config, Zero, 0x0100)
+ *        Field (THCR, ByteAcc, NoLock, Preserve)
+ *        {
+ *            // Vendor ID field in the PCI configuration space
+ *            VDID,   32
+ *        }
+ *
+ *        // Check if the device at 00:10.06 actually exists, that is reading
+ *        // from its configuration space returns something other than 0xFFs.
+ *        If ((VDID != 0xFFFFFFFF))
+ *        {
+ *            // Actually create the rest of the device's body if it's present
+ *            // in the system, otherwise skip it.
+ *        }
+ *    }
+ *
+ * The handle returned via 'out_handle' is used to perform IO on the
+ * configuration space of the device.
+ */
+uacpi_status uacpi_kernel_pci_device_open(
+    uacpi_pci_address address, uacpi_handle *out_handle
+);
+void uacpi_kernel_pci_device_close(uacpi_handle);
+
+/*
+ * Read & write the configuration space of a previously open PCI device.
+ */
+uacpi_status uacpi_kernel_pci_read8(
+    uacpi_handle device, uacpi_size offset, uacpi_u8 *value
+);
+uacpi_status uacpi_kernel_pci_read16(
+    uacpi_handle device, uacpi_size offset, uacpi_u16 *value
+);
+uacpi_status uacpi_kernel_pci_read32(
+    uacpi_handle device, uacpi_size offset, uacpi_u32 *value
+);
+
+uacpi_status uacpi_kernel_pci_write8(
+    uacpi_handle device, uacpi_size offset, uacpi_u8 value
+);
+uacpi_status uacpi_kernel_pci_write16(
+    uacpi_handle device, uacpi_size offset, uacpi_u16 value
+);
+uacpi_status uacpi_kernel_pci_write32(
+    uacpi_handle device, uacpi_size offset, uacpi_u32 value
+);
+
+/*
+ * Map a SystemIO address at [base, base + len) and return a kernel-implemented
+ * handle that can be used for reading and writing the IO range.
+ *
+ * NOTE: The x86 architecture uses the in/out family of instructions
+ *       to access the SystemIO address space.
+ */
+uacpi_status uacpi_kernel_io_map(
+    uacpi_io_addr base, uacpi_size len, uacpi_handle *out_handle
+);
+void uacpi_kernel_io_unmap(uacpi_handle handle);
+
+/*
+ * Read/Write the IO range mapped via uacpi_kernel_io_map
+ * at a 0-based 'offset' within the range.
+ *
+ * NOTE:
+ * The x86 architecture uses the in/out family of instructions
+ * to access the SystemIO address space.
+ *
+ * You are NOT allowed to break e.g. a 4-byte access into four 1-byte accesses.
+ * Hardware ALWAYS expects accesses to be of the exact width.
+ */
+uacpi_status uacpi_kernel_io_read8(
+    uacpi_handle, uacpi_size offset, uacpi_u8 *out_value
+);
+uacpi_status uacpi_kernel_io_read16(
+    uacpi_handle, uacpi_size offset, uacpi_u16 *out_value
+);
+uacpi_status uacpi_kernel_io_read32(
+    uacpi_handle, uacpi_size offset, uacpi_u32 *out_value
+);
+
+uacpi_status uacpi_kernel_io_write8(
+    uacpi_handle, uacpi_size offset, uacpi_u8 in_value
+);
+uacpi_status uacpi_kernel_io_write16(
+    uacpi_handle, uacpi_size offset, uacpi_u16 in_value
+);
+uacpi_status uacpi_kernel_io_write32(
+    uacpi_handle, uacpi_size offset, uacpi_u32 in_value
+);
+
+/*
+ * Allocate a block of memory of 'size' bytes.
+ * The contents of the allocated memory are unspecified.
+ */
+void *uacpi_kernel_alloc(uacpi_size size);
+
+#ifdef UACPI_NATIVE_ALLOC_ZEROED
+/*
+ * Allocate a block of memory of 'size' bytes.
+ * The returned memory block is expected to be zero-filled.
+ */
+void *uacpi_kernel_alloc_zeroed(uacpi_size size);
+#endif
+
+/*
+ * Free a previously allocated memory block.
+ *
+ * 'mem' might be a NULL pointer. In this case, the call is assumed to be a
+ * no-op.
+ *
+ * An optionally enabled 'size_hint' parameter contains the size of the original
+ * allocation. Note that in some scenarios this incurs additional cost to
+ * calculate the object size.
+ */
+#ifndef UACPI_SIZED_FREES
+void uacpi_kernel_free(void *mem);
+#else
+void uacpi_kernel_free(void *mem, uacpi_size size_hint);
+#endif
+
+/*
+ * Returns the number of nanosecond ticks elapsed since boot,
+ * strictly monotonic.
+ */
+uacpi_u64 uacpi_kernel_get_nanoseconds_since_boot(void);
+
+/*
+ * Spin for N microseconds.
+ */
+void uacpi_kernel_stall(uacpi_u8 usec);
+
+/*
+ * Sleep for N milliseconds.
+ */
+void uacpi_kernel_sleep(uacpi_u64 msec);
+
+/*
+ * Create/free an opaque non-recursive kernel mutex object.
+ */
+uacpi_handle uacpi_kernel_create_mutex(void);
+void uacpi_kernel_free_mutex(uacpi_handle);
+
+/*
+ * Create/free an opaque kernel (semaphore-like) event object.
+ */
+uacpi_handle uacpi_kernel_create_event(void);
+void uacpi_kernel_free_event(uacpi_handle);
+
+/*
+ * Returns a unique identifier of the currently executing thread.
+ *
+ * The returned thread id cannot be UACPI_THREAD_ID_NONE.
+ */
+uacpi_thread_id uacpi_kernel_get_thread_id(void);
+
+/*
+ * Try to acquire the mutex with a millisecond timeout.
+ *
+ * The timeout value has the following meanings:
+ * 0x0000 - Attempt to acquire the mutex once, in a non-blocking manner
+ * 0x0001...0xFFFE - Attempt to acquire the mutex for at least 'timeout'
+ *                   milliseconds
+ * 0xFFFF - Infinite wait, block until the mutex is acquired
+ *
+ * The following are possible return values:
+ * 1. UACPI_STATUS_OK - successful acquire operation
+ * 2. UACPI_STATUS_TIMEOUT - timeout reached while attempting to acquire (or the
+ *                           single attempt to acquire was not successful for
+ *                           calls with timeout=0)
+ * 3. Any other value - signifies a host internal error and is treated as such
+ */
+uacpi_status uacpi_kernel_acquire_mutex(uacpi_handle, uacpi_u16);
+void uacpi_kernel_release_mutex(uacpi_handle);
+
+/*
+ * Try to wait for an event (counter > 0) with a millisecond timeout.
+ * A timeout value of 0xFFFF implies infinite wait.
+ *
+ * The internal counter is decremented by 1 if wait was successful.
+ *
+ * A successful wait is indicated by returning UACPI_TRUE.
+ */
+uacpi_bool uacpi_kernel_wait_for_event(uacpi_handle, uacpi_u16);
+
+/*
+ * Signal the event object by incrementing its internal counter by 1.
+ *
+ * This function may be used in interrupt contexts.
+ */
+void uacpi_kernel_signal_event(uacpi_handle);
+
+/*
+ * Reset the event counter to 0.
+ */
+void uacpi_kernel_reset_event(uacpi_handle);
+
+/*
+ * Handle a firmware request.
+ *
+ * Currently either a Breakpoint or Fatal operators.
+ */
+uacpi_status uacpi_kernel_handle_firmware_request(uacpi_firmware_request*);
+
+/*
+ * Install an interrupt handler at 'irq', 'ctx' is passed to the provided
+ * handler for every invocation.
+ *
+ * 'out_irq_handle' is set to a kernel-implemented value that can be used to
+ * refer to this handler from other API.
+ */
+uacpi_status uacpi_kernel_install_interrupt_handler(
+    uacpi_u32 irq, uacpi_interrupt_handler, uacpi_handle ctx,
+    uacpi_handle *out_irq_handle
+);
+
+/*
+ * Uninstall an interrupt handler. 'irq_handle' is the value returned via
+ * 'out_irq_handle' during installation.
+ */
+uacpi_status uacpi_kernel_uninstall_interrupt_handler(
+    uacpi_interrupt_handler, uacpi_handle irq_handle
+);
+
+/*
+ * Create/free a kernel spinlock object.
+ *
+ * Unlike other types of locks, spinlocks may be used in interrupt contexts.
+ */
+uacpi_handle uacpi_kernel_create_spinlock(void);
+void uacpi_kernel_free_spinlock(uacpi_handle);
+
+/*
+ * Lock/unlock helpers for spinlocks.
+ *
+ * These are expected to disable interrupts, returning the previous state of cpu
+ * flags, that can be used to possibly re-enable interrupts if they were enabled
+ * before.
+ *
+ * Note that lock is infalliable.
+ */
+uacpi_cpu_flags uacpi_kernel_lock_spinlock(uacpi_handle);
+void uacpi_kernel_unlock_spinlock(uacpi_handle, uacpi_cpu_flags);
+
+typedef enum uacpi_work_type {
+    /*
+     * Schedule a GPE handler method for execution.
+     * This should be scheduled to run on CPU0 to avoid potential SMI-related
+     * firmware bugs.
+     */
+    UACPI_WORK_GPE_EXECUTION,
+
+    /*
+     * Schedule a Notify(device) firmware request for execution.
+     * This can run on any CPU.
+     */
+    UACPI_WORK_NOTIFICATION,
+} uacpi_work_type;
+
+typedef void (*uacpi_work_handler)(uacpi_handle);
+
+/*
+ * Schedules deferred work for execution.
+ * Might be invoked from an interrupt context.
+ */
+uacpi_status uacpi_kernel_schedule_work(
+    uacpi_work_type, uacpi_work_handler, uacpi_handle ctx
+);
+
+/*
+ * Waits for two types of work to finish:
+ * 1. All in-flight interrupts installed via uacpi_kernel_install_interrupt_handler
+ * 2. All work scheduled via uacpi_kernel_schedule_work
+ *
+ * Note that the waits must be done in this order specifically.
+ */
+uacpi_status uacpi_kernel_wait_for_work_completion(void);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/log.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum uacpi_log_level {
+    /*
+     * Super verbose logging, every op & uop being processed is logged.
+     * Mostly useful for tracking down hangs/lockups.
+     */
+    UACPI_LOG_DEBUG = 5,
+
+    /*
+     * A little verbose, every operation region access is traced with a bit of
+     * extra information on top.
+     */
+    UACPI_LOG_TRACE = 4,
+
+    /*
+     * Only logs the bare minimum information about state changes and/or
+     * initialization progress.
+     */
+    UACPI_LOG_INFO = 3,
+
+    /*
+     * Logs recoverable errors and/or non-important aborts.
+     */
+    UACPI_LOG_WARN = 2,
+
+    /*
+     * Logs only critical errors that might affect the ability to initialize or
+     * prevent stable runtime.
+     */
+    UACPI_LOG_ERROR = 1,
+} uacpi_log_level;
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/namespace.h

@@ -0,0 +1,186 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef struct uacpi_namespace_node uacpi_namespace_node;
+
+uacpi_namespace_node *uacpi_namespace_root(void);
+
+typedef enum uacpi_predefined_namespace {
+    UACPI_PREDEFINED_NAMESPACE_ROOT = 0,
+    UACPI_PREDEFINED_NAMESPACE_GPE,
+    UACPI_PREDEFINED_NAMESPACE_PR,
+    UACPI_PREDEFINED_NAMESPACE_SB,
+    UACPI_PREDEFINED_NAMESPACE_SI,
+    UACPI_PREDEFINED_NAMESPACE_TZ,
+    UACPI_PREDEFINED_NAMESPACE_GL,
+    UACPI_PREDEFINED_NAMESPACE_OS,
+    UACPI_PREDEFINED_NAMESPACE_OSI,
+    UACPI_PREDEFINED_NAMESPACE_REV,
+    UACPI_PREDEFINED_NAMESPACE_MAX = UACPI_PREDEFINED_NAMESPACE_REV,
+} uacpi_predefined_namespace;
+uacpi_namespace_node *uacpi_namespace_get_predefined(
+    uacpi_predefined_namespace
+);
+
+/*
+ * Returns UACPI_TRUE if the provided 'node' is an alias.
+ */
+uacpi_bool uacpi_namespace_node_is_alias(uacpi_namespace_node *node);
+
+uacpi_object_name uacpi_namespace_node_name(const uacpi_namespace_node *node);
+
+/*
+ * Returns the type of object stored at the namespace node.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_type(
+    const uacpi_namespace_node *node, uacpi_object_type *out_type
+);
+
+/*
+ * Returns UACPI_TRUE via 'out' if the type of the object stored at the
+ * namespace node matches the provided value, UACPI_FALSE otherwise.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_is(
+    const uacpi_namespace_node *node, uacpi_object_type type, uacpi_bool *out
+);
+
+/*
+ * Returns UACPI_TRUE via 'out' if the type of the object stored at the
+ * namespace node matches any of the type bits in the provided value,
+ * UACPI_FALSE otherwise.
+ *
+ * NOTE: due to the existance of the CopyObject operator in AML, the
+ *       return value of this function is subject to TOCTOU bugs.
+ */
+uacpi_status uacpi_namespace_node_is_one_of(
+    const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+    uacpi_bool *out
+);
+
+uacpi_size uacpi_namespace_node_depth(const uacpi_namespace_node *node);
+
+uacpi_namespace_node *uacpi_namespace_node_parent(
+    uacpi_namespace_node *node
+);
+
+uacpi_status uacpi_namespace_node_find(
+    uacpi_namespace_node *parent,
+    const uacpi_char *path,
+    uacpi_namespace_node **out_node
+);
+
+/*
+ * Same as uacpi_namespace_node_find, except the search recurses upwards when
+ * the namepath consists of only a single nameseg. Usually, this behavior is
+ * only desired if resolving a namepath specified in an aml-provided object,
+ * such as a package element.
+ */
+uacpi_status uacpi_namespace_node_resolve_from_aml_namepath(
+    uacpi_namespace_node *scope,
+    const uacpi_char *path,
+    uacpi_namespace_node **out_node
+);
+
+typedef uacpi_iteration_decision (*uacpi_iteration_callback) (
+    void *user, uacpi_namespace_node *node, uacpi_u32 node_depth
+);
+
+#define UACPI_MAX_DEPTH_ANY 0xFFFFFFFF
+
+/*
+ * Depth-first iterate the namespace starting at the first child of 'parent'.
+ */
+uacpi_status uacpi_namespace_for_each_child_simple(
+    uacpi_namespace_node *parent, uacpi_iteration_callback callback, void *user
+);
+
+/*
+ * Depth-first iterate the namespace starting at the first child of 'parent'.
+ *
+ * 'descending_callback' is invoked the first time a node is visited when
+ * walking down. 'ascending_callback' is invoked the second time a node is
+ * visited after we reach the leaf node without children and start walking up.
+ * Either of the callbacks may be NULL, but not both at the same time.
+ *
+ * Only nodes matching 'type_mask' are passed to the callbacks.
+ *
+ * 'max_depth' is used to limit the maximum reachable depth from 'parent',
+ * where 1 is only direct children of 'parent', 2 is children of first-level
+ * children etc. Use UACPI_MAX_DEPTH_ANY or -1 to specify infinite depth.
+ */
+uacpi_status uacpi_namespace_for_each_child(
+    uacpi_namespace_node *parent, uacpi_iteration_callback descending_callback,
+    uacpi_iteration_callback ascending_callback,
+    uacpi_object_type_bits type_mask, uacpi_u32 max_depth, void *user
+);
+
+/*
+ * Retrieve the next peer namespace node of '*iter', or, if '*iter' is
+ * UACPI_NULL, retrieve the first child of 'parent' instead. The resulting
+ * namespace node is stored at '*iter'.
+ *
+ * This API can be used to implement an "iterator" version of the
+ * for_each_child helpers.
+ *
+ * Example usage:
+ *     void recurse(uacpi_namespace_node *parent) {
+ *        uacpi_namespace_node *iter = UACPI_NULL;
+ *
+ *        while (uacpi_namespace_node_next(parent, &iter) == UACPI_STATUS_OK) {
+ *             // Do something with iter...
+ *             descending_callback(iter);
+ *
+ *             // Recurse down to walk over the children of iter
+ *             recurse(iter);
+ *        }
+ *     }
+ *
+ * Prefer the for_each_child family of helpers if possible instead of this API
+ * as they avoid recursion and/or the need to use dynamic data structures
+ * entirely.
+ */
+uacpi_status uacpi_namespace_node_next(
+    uacpi_namespace_node *parent, uacpi_namespace_node **iter
+);
+
+/*
+ * Retrieve the next peer namespace node of '*iter', or, if '*iter' is
+ * UACPI_NULL, retrieve the first child of 'parent' instead. The resulting
+ * namespace node is stored at '*iter'. Only nodes which type matches one
+ * of the types set in 'type_mask' are returned.
+ *
+ * See comment above 'uacpi_namespace_node_next' for usage examples.
+ *
+ * Prefer the for_each_child family of helpers if possible instead of this API
+ * as they avoid recursion and/or the need to use dynamic data structures
+ * entirely.
+ */
+uacpi_status uacpi_namespace_node_next_typed(
+    uacpi_namespace_node *parent, uacpi_namespace_node **iter,
+    uacpi_object_type_bits type_mask
+);
+
+const uacpi_char *uacpi_namespace_node_generate_absolute_path(
+    const uacpi_namespace_node *node
+);
+void uacpi_free_absolute_path(const uacpi_char *path);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/notify.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Install a Notify() handler to a device node.
+ * A handler installed to the root node will receive all notifications, even if
+ * a device already has a dedicated Notify handler.
+ * 'handler_context' is passed to the handler on every invocation.
+ */
+uacpi_status uacpi_install_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler,
+    uacpi_handle handler_context
+);
+
+uacpi_status uacpi_uninstall_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/opregion.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Install an address space handler to a device node.
+ * The handler is recursively connected to all of the operation regions of
+ * type 'space' underneath 'device_node'. Note that this recursion stops as
+ * soon as another device node that already has an address space handler of
+ * this type installed is encountered.
+ */
+uacpi_status uacpi_install_address_space_handler(
+    uacpi_namespace_node *device_node, enum uacpi_address_space space,
+    uacpi_region_handler handler, uacpi_handle handler_context
+);
+
+/*
+ * Uninstall the handler of type 'space' from a given device node.
+ */
+uacpi_status uacpi_uninstall_address_space_handler(
+    uacpi_namespace_node *device_node,
+    enum uacpi_address_space space
+);
+
+/*
+ * Execute _REG(space, ACPI_REG_CONNECT) for all of the opregions with this
+ * address space underneath this device. This should only be called manually
+ * if you want to register an early handler that must be available before the
+ * call to uacpi_namespace_initialize().
+ */
+uacpi_status uacpi_reg_all_opregions(
+    uacpi_namespace_node *device_node,
+    enum uacpi_address_space space
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/osi.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_vendor_interface {
+    UACPI_VENDOR_INTERFACE_NONE = 0,
+    UACPI_VENDOR_INTERFACE_WINDOWS_2000,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2003,
+    UACPI_VENDOR_INTERFACE_WINDOWS_XP_SP2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2003_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA,
+    UACPI_VENDOR_INTERFACE_WINDOWS_SERVER_2008,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA_SP1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_VISTA_SP2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_7,
+    UACPI_VENDOR_INTERFACE_WINDOWS_8,
+    UACPI_VENDOR_INTERFACE_WINDOWS_8_1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS2,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS3,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS4,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_RS5,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_19H1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_10_20H1,
+    UACPI_VENDOR_INTERFACE_WINDOWS_11,
+    UACPI_VENDOR_INTERFACE_WINDOWS_11_22H2,
+} uacpi_vendor_interface;
+
+/*
+ * Returns the "latest" AML-queried _OSI vendor interface.
+ *
+ * E.g. for the following AML code:
+ *     _OSI("Windows 2021")
+ *     _OSI("Windows 2000")
+ *
+ * This function will return UACPI_VENDOR_INTERFACE_WINDOWS_11, since this is
+ * the latest version of the interface the code queried, even though the
+ * "Windows 2000" query came after "Windows 2021".
+ */
+uacpi_vendor_interface uacpi_latest_queried_vendor_interface(void);
+
+typedef enum uacpi_interface_kind {
+    UACPI_INTERFACE_KIND_VENDOR = (1 << 0),
+    UACPI_INTERFACE_KIND_FEATURE = (1 << 1),
+    UACPI_INTERFACE_KIND_ALL = UACPI_INTERFACE_KIND_VENDOR |
+                               UACPI_INTERFACE_KIND_FEATURE,
+} uacpi_interface_kind;
+
+/*
+ * Install or uninstall an interface.
+ *
+ * The interface kind is used for matching during interface enumeration in
+ * uacpi_bulk_configure_interfaces().
+ *
+ * After installing an interface, all _OSI queries report it as supported.
+ */
+uacpi_status uacpi_install_interface(
+    const uacpi_char *name, uacpi_interface_kind
+);
+uacpi_status uacpi_uninstall_interface(const uacpi_char *name);
+
+typedef enum uacpi_host_interface {
+    UACPI_HOST_INTERFACE_MODULE_DEVICE = 1,
+    UACPI_HOST_INTERFACE_PROCESSOR_DEVICE,
+    UACPI_HOST_INTERFACE_3_0_THERMAL_MODEL,
+    UACPI_HOST_INTERFACE_3_0_SCP_EXTENSIONS,
+    UACPI_HOST_INTERFACE_PROCESSOR_AGGREGATOR_DEVICE,
+} uacpi_host_interface;
+
+/*
+ * Same as install/uninstall interface, but comes with an enum of known
+ * interfaces defined by the ACPI specification. These are disabled by default
+ * as they depend on the host kernel support.
+ */
+uacpi_status uacpi_enable_host_interface(uacpi_host_interface);
+uacpi_status uacpi_disable_host_interface(uacpi_host_interface);
+
+typedef uacpi_bool (*uacpi_interface_handler)
+    (const uacpi_char *name, uacpi_bool supported);
+
+/*
+ * Set a custom interface query (_OSI) handler.
+ *
+ * This callback will be invoked for each _OSI query with the value
+ * passed in the _OSI, as well as whether the interface was detected as
+ * supported. The callback is able to override the return value dynamically
+ * or leave it untouched if desired (e.g. if it simply wants to log something or
+ * do internal bookkeeping of some kind).
+ */
+uacpi_status uacpi_set_interface_query_handler(uacpi_interface_handler);
+
+typedef enum uacpi_interface_action {
+    UACPI_INTERFACE_ACTION_DISABLE = 0,
+    UACPI_INTERFACE_ACTION_ENABLE,
+} uacpi_interface_action;
+
+/*
+ * Bulk interface configuration, used to disable or enable all interfaces that
+ * match 'kind'.
+ *
+ * This is generally only needed to work around buggy hardware, for example if
+ * requested from the kernel command line.
+ *
+ * By default, all vendor strings (like "Windows 2000") are enabled, and all
+ * host features (like "3.0 Thermal Model") are disabled.
+ */
+uacpi_status uacpi_bulk_configure_interfaces(
+    uacpi_interface_action action, uacpi_interface_kind kind
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/arch_helpers.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_ARCH_HELPERS
+#include "uacpi_arch_helpers.h"
+#else
+
+#include <uacpi/platform/atomic.h>
+
+#ifndef UACPI_ARCH_FLUSH_CPU_CACHE
+#define UACPI_ARCH_FLUSH_CPU_CACHE() do {} while (0)
+#endif
+
+typedef unsigned long uacpi_cpu_flags;
+
+typedef void *uacpi_thread_id;
+
+/*
+ * Replace as needed depending on your platform's way to represent thread ids.
+ * uACPI offers a few more helpers like uacpi_atomic_{load,store}{8,16,32,64,ptr}
+ * (or you could provide your own helpers)
+ */
+#ifndef UACPI_ATOMIC_LOAD_THREAD_ID
+#define UACPI_ATOMIC_LOAD_THREAD_ID(ptr) ((uacpi_thread_id)uacpi_atomic_load_ptr(ptr))
+#endif
+
+#ifndef UACPI_ATOMIC_STORE_THREAD_ID
+#define UACPI_ATOMIC_STORE_THREAD_ID(ptr, value) uacpi_atomic_store_ptr(ptr, value)
+#endif
+
+/*
+ * A sentinel value that the kernel promises to NEVER return from
+ * uacpi_kernel_get_current_thread_id or this will break
+ */
+#ifndef UACPI_THREAD_ID_NONE
+#define UACPI_THREAD_ID_NONE ((uacpi_thread_id)-1)
+#endif
+
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/atomic.h

@@ -0,0 +1,129 @@
+#pragma once
+
+/*
+ * Most of this header is a giant workaround for MSVC to make atomics into a
+ * somewhat unified interface with how GCC and Clang handle them.
+ *
+ * We don't use the absolutely disgusting C11 stdatomic.h header because it is
+ * unable to operate on non _Atomic types, which enforce implicit sequential
+ * consistency and alter the behavior of the standard C binary/unary operators.
+ *
+ * The strictness of the atomic helpers defined here is assumed to be at least
+ * acquire for loads and release for stores. Cmpxchg uses the standard acq/rel
+ * for success, acq for failure, and is assumed to be strong.
+ */
+
+#ifdef UACPI_OVERRIDE_ATOMIC
+#include "uacpi_atomic.h"
+#else
+
+#include <uacpi/platform/compiler.h>
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#include <intrin.h>
+
+// mimic __atomic_compare_exchange_n that doesn't exist on MSVC
+#define UACPI_MAKE_MSVC_CMPXCHG(width, type, suffix)                            \
+    static inline int uacpi_do_atomic_cmpxchg##width(                           \
+        type volatile *ptr, type volatile *expected, type desired               \
+    )                                                                           \
+    {                                                                           \
+        type current;                                                           \
+                                                                                \
+        current = _InterlockedCompareExchange##suffix(ptr, *expected, desired); \
+        if (current != *expected) {                                             \
+            *expected = current;                                                \
+            return 0;                                                           \
+        }                                                                       \
+        return 1;                                                               \
+    }
+
+#define UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, width, type) \
+    uacpi_do_atomic_cmpxchg##width(                                    \
+        (type volatile*)ptr, (type volatile*)expected, desired         \
+    )
+
+#define UACPI_MSVC_ATOMIC_STORE(ptr, value, type, width) \
+    _InterlockedExchange##width((type volatile*)(ptr), (type)(value))
+
+#define UACPI_MSVC_ATOMIC_LOAD(ptr, type, width) \
+    _InterlockedOr##width((type volatile*)(ptr), 0)
+
+#define UACPI_MSVC_ATOMIC_INC(ptr, type, width) \
+    _InterlockedIncrement##width((type volatile*)(ptr))
+
+#define UACPI_MSVC_ATOMIC_DEC(ptr, type, width) \
+    _InterlockedDecrement##width((type volatile*)(ptr))
+
+UACPI_MAKE_MSVC_CMPXCHG(64, __int64, 64)
+UACPI_MAKE_MSVC_CMPXCHG(32, long,)
+UACPI_MAKE_MSVC_CMPXCHG(16, short, 16)
+
+#define uacpi_atomic_cmpxchg16(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 16, short)
+
+#define uacpi_atomic_cmpxchg32(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 32, long)
+
+#define uacpi_atomic_cmpxchg64(ptr, expected, desired) \
+    UACPI_MSVC_CMPXCHG_INVOKE(ptr, expected, desired, 64, __int64)
+
+#define uacpi_atomic_load8(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, char, 8)
+#define uacpi_atomic_load16(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, short, 16)
+#define uacpi_atomic_load32(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, long,)
+#define uacpi_atomic_load64(ptr) UACPI_MSVC_ATOMIC_LOAD(ptr, __int64, 64)
+
+#define uacpi_atomic_store8(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, char, 8)
+#define uacpi_atomic_store16(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, short, 16)
+#define uacpi_atomic_store32(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, long,)
+#define uacpi_atomic_store64(ptr, value) UACPI_MSVC_ATOMIC_STORE(ptr, value, __int64, 64)
+
+#define uacpi_atomic_inc16(ptr) UACPI_MSVC_ATOMIC_INC(ptr, short, 16)
+#define uacpi_atomic_inc32(ptr) UACPI_MSVC_ATOMIC_INC(ptr, long,)
+#define uacpi_atomic_inc64(ptr) UACPI_MSVC_ATOMIC_INC(ptr, __int64, 64)
+
+#define uacpi_atomic_dec16(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, short, 16)
+#define uacpi_atomic_dec32(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, long,)
+#define uacpi_atomic_dec64(ptr) UACPI_MSVC_ATOMIC_DEC(ptr, __int64, 64)
+#else
+
+#define UACPI_DO_CMPXCHG(ptr, expected, desired)           \
+    __atomic_compare_exchange_n(ptr, expected, desired, 0, \
+                                __ATOMIC_ACQ_REL, __ATOMIC_ACQUIRE)
+
+#define uacpi_atomic_cmpxchg16(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+#define uacpi_atomic_cmpxchg32(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+#define uacpi_atomic_cmpxchg64(ptr, expected, desired) \
+    UACPI_DO_CMPXCHG(ptr, expected, desired)
+
+#define uacpi_atomic_load8(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load16(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load32(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+#define uacpi_atomic_load64(ptr) __atomic_load_n(ptr, __ATOMIC_ACQUIRE)
+
+#define uacpi_atomic_store8(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store16(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store32(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+#define uacpi_atomic_store64(ptr, value) __atomic_store_n(ptr, value, __ATOMIC_RELEASE)
+
+#define uacpi_atomic_inc16(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_inc32(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_inc64(ptr) __atomic_add_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+
+#define uacpi_atomic_dec16(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_dec32(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#define uacpi_atomic_dec64(ptr) __atomic_sub_fetch(ptr, 1, __ATOMIC_ACQ_REL)
+#endif
+
+#if UACPI_POINTER_SIZE == 4
+#define uacpi_atomic_load_ptr(ptr_to_ptr) uacpi_atomic_load32(ptr_to_ptr)
+#define uacpi_atomic_store_ptr(ptr_to_ptr, value) uacpi_atomic_store32(ptr_to_ptr, value)
+#else
+#define uacpi_atomic_load_ptr(ptr_to_ptr) uacpi_atomic_load64(ptr_to_ptr)
+#define uacpi_atomic_store_ptr(ptr_to_ptr, value) uacpi_atomic_store64(ptr_to_ptr, value)
+#endif
+
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/compiler.h

@@ -0,0 +1,87 @@
+#pragma once
+
+/*
+ * Compiler-specific attributes/macros go here. This is the default placeholder
+ * that should work for MSVC/GCC/clang.
+ */
+
+#ifdef UACPI_OVERRIDE_COMPILER
+#include "uacpi_compiler.h"
+#else
+
+#define UACPI_ALIGN(x) __declspec(align(x))
+
+#ifdef _MSC_VER
+    #include <intrin.h>
+
+    #define UACPI_ALWAYS_INLINE __forceinline
+
+    #define UACPI_PACKED(decl)  \
+        __pragma(pack(push, 1)) \
+        decl;                   \
+        __pragma(pack(pop))
+#else
+    #define UACPI_ALWAYS_INLINE inline __attribute__((always_inline))
+    #define UACPI_PACKED(decl) decl __attribute__((packed));
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define uacpi_unlikely(expr) __builtin_expect(!!(expr), 0)
+    #define uacpi_likely(expr)   __builtin_expect(!!(expr), 1)
+
+    #if __has_attribute(__fallthrough__)
+        #define UACPI_FALLTHROUGH __attribute__((__fallthrough__))
+    #endif
+
+    #define UACPI_MAYBE_UNUSED __attribute__ ((unused))
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN             \
+        _Pragma("GCC diagnostic push")                           \
+        _Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_END \
+        _Pragma("GCC diagnostic pop")
+
+    #ifdef __clang__
+        #define UACPI_PRINTF_DECL(fmt_idx, args_idx) \
+            __attribute__((format(printf, fmt_idx, args_idx)))
+    #else
+        #define UACPI_PRINTF_DECL(fmt_idx, args_idx) \
+            __attribute__((format(gnu_printf, fmt_idx, args_idx)))
+    #endif
+
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMCPY
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMMOVE
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMSET
+    #define UACPI_COMPILER_HAS_BUILTIN_MEMCMP
+#else
+    #define uacpi_unlikely(expr) expr
+    #define uacpi_likely(expr)   expr
+
+    #define UACPI_MAYBE_UNUSED
+
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN
+    #define UACPI_NO_UNUSED_PARAMETER_WARNINGS_END
+
+    #define UACPI_PRINTF_DECL(fmt_idx, args_idx)
+#endif
+
+#ifndef UACPI_FALLTHROUGH
+    #define UACPI_FALLTHROUGH do {} while (0)
+#endif
+
+#ifndef UACPI_POINTER_SIZE
+    #ifdef _WIN32
+        #ifdef _WIN64
+            #define UACPI_POINTER_SIZE 8
+        #else
+            #define UACPI_POINTER_SIZE 4
+        #endif
+    #elif defined(__GNUC__)
+        #define UACPI_POINTER_SIZE __SIZEOF_POINTER__
+    #else
+        #error Failed to detect pointer size
+    #endif
+#endif
+
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/config.h

@@ -0,0 +1,162 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_CONFIG
+#include "uacpi_config.h"
+#else
+
+#include <uacpi/helpers.h>
+#include <uacpi/log.h>
+
+/*
+ * =======================
+ * Context-related options
+ * =======================
+ */
+#ifndef UACPI_DEFAULT_LOG_LEVEL
+    #define UACPI_DEFAULT_LOG_LEVEL UACPI_LOG_INFO
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_LOG_LEVEL < UACPI_LOG_ERROR ||
+    UACPI_DEFAULT_LOG_LEVEL > UACPI_LOG_DEBUG,
+    "configured default log level is invalid"
+);
+
+#ifndef UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS
+    #define UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS 30
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS < 1,
+    "configured default loop timeout is invalid (expecting at least 1 second)"
+);
+
+#ifndef UACPI_DEFAULT_MAX_CALL_STACK_DEPTH
+    #define UACPI_DEFAULT_MAX_CALL_STACK_DEPTH 256
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_DEFAULT_MAX_CALL_STACK_DEPTH < 4,
+    "configured default max call stack depth is invalid "
+    "(expecting at least 4 frames)"
+);
+
+/*
+ * ===================
+ * Kernel-api options
+ * ===================
+ */
+
+/*
+ * Convenience initialization/deinitialization hooks that will be called by
+ * uACPI automatically when appropriate if compiled-in.
+ */
+// #define UACPI_KERNEL_INITIALIZATION
+
+/*
+ * Makes kernel api logging callbacks work with unformatted printf-style
+ * strings and va_args instead of a pre-formatted string. Can be useful if
+ * your native logging is implemented in terms of this format as well.
+ */
+// #define UACPI_FORMATTED_LOGGING
+
+/*
+ * Makes uacpi_kernel_free take in an additional 'size_hint' parameter, which
+ * contains the size of the original allocation. Note that this comes with a
+ * performance penalty in some cases.
+ */
+// #define UACPI_SIZED_FREES
+
+
+/*
+ * Makes uacpi_kernel_alloc_zeroed mandatory to implement by the host, uACPI
+ * will not provide a default implementation if this is enabled.
+ */
+// #define UACPI_NATIVE_ALLOC_ZEROED
+
+/*
+ * =========================
+ * Platform-specific options
+ * =========================
+ */
+
+/*
+ * Makes uACPI use the internal versions of mem{cpy,move,set,cmp} instead of
+ * relying on the host to provide them. Note that compilers like clang and GCC
+ * rely on these being available by default, even in freestanding mode, so
+ * compiling uACPI may theoretically generate implicit dependencies on them
+ * even if this option is defined.
+ */
+// #define UACPI_USE_BUILTIN_STRING
+
+/*
+ * Turns uacpi_phys_addr and uacpi_io_addr into a 32-bit type, and adds extra
+ * code for address truncation. Needed for e.g. i686 platforms without PAE
+ * support.
+ */
+// #define UACPI_PHYS_ADDR_IS_32BITS
+
+/*
+ * Switches uACPI into reduced-hardware-only mode. Strips all full-hardware
+ * ACPI support code at compile-time, including the event subsystem, the global
+ * lock, and other full-hardware features.
+ */
+// #define UACPI_REDUCED_HARDWARE
+
+/*
+ * Switches uACPI into tables-subsystem-only mode and strips all other code.
+ * This means only the table API will be usable, no other subsystems are
+ * compiled in. In this mode, uACPI only depends on the following kernel APIs:
+ * - uacpi_kernel_get_rsdp
+ * - uacpi_kernel_{map,unmap}
+ * - uacpi_kernel_log
+ *
+ * Use uacpi_setup_early_table_access to initialize, uacpi_state_reset to
+ * deinitialize.
+ *
+ * This mode is primarily designed for these three use-cases:
+ * - Bootloader/pre-kernel environments that need to parse ACPI tables, but
+ *   don't actually need a fully-featured AML interpreter, and everything else
+ *   that a full APCI implementation entails.
+ * - A micro-kernel that has the full AML interpreter running in userspace, but
+ *   still needs to parse ACPI tables to bootstrap allocators, timers, SMP etc.
+ * - A WIP kernel that needs to parse ACPI tables for bootrapping SMP/timers,
+ *   ECAM, etc., but doesn't yet have enough subsystems implemented in order
+ *   to run a fully-featured AML interpreter.
+ */
+// #define UACPI_BAREBONES_MODE
+
+/*
+ * =============
+ * Misc. options
+ * =============
+ */
+
+/*
+ * If UACPI_FORMATTED_LOGGING is not enabled, this is the maximum length of the
+ * pre-formatted message that is passed to the logging callback.
+ */
+#ifndef UACPI_PLAIN_LOG_BUFFER_SIZE
+    #define UACPI_PLAIN_LOG_BUFFER_SIZE 128
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_PLAIN_LOG_BUFFER_SIZE < 16,
+    "configured log buffer size is too small (expecting at least 16 bytes)"
+);
+
+/*
+ * The size of the table descriptor inline storage. All table descriptors past
+ * this length will be stored in a dynamically allocated heap array. The size
+ * of one table descriptor is approximately 56 bytes.
+ */
+#ifndef UACPI_STATIC_TABLE_ARRAY_LEN
+    #define UACPI_STATIC_TABLE_ARRAY_LEN 16
+#endif
+
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    UACPI_STATIC_TABLE_ARRAY_LEN < 1,
+    "configured static table array length is too small (expecting at least 1)"
+);
+
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/libc.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#ifdef UACPI_OVERRIDE_LIBC
+#include "uacpi_libc.h"
+#else
+/*
+ * The following libc functions are used internally by uACPI and have a default
+ * (sub-optimal) implementation:
+ * - strcmp
+ * - strnlen
+ * - strlen
+ * - snprintf
+ * - vsnprintf
+ *
+ * The following use a builtin implementation only if UACPI_USE_BUILTIN_STRING
+ * is defined (more information can be found in the config.h header):
+ * - memcpy
+ * - memmove
+ * - memset
+ * - memcmp
+ *
+ * In case your platform happens to implement optimized verisons of the helpers
+ * above, you are able to make uACPI use those instead by overriding them like so:
+ *
+ * #define uacpi_memcpy my_fast_memcpy
+ * #define uacpi_snprintf my_fast_snprintf
+ */
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/platform/types.h

@@ -0,0 +1,64 @@
+#pragma once
+
+/*
+ * Platform-specific types go here. This is the default placeholder using
+ * types from the standard headers.
+ */
+
+#ifdef UACPI_OVERRIDE_TYPES
+#include "uacpi_types.h"
+#else
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+
+#include <uacpi/helpers.h>
+
+typedef uint8_t uacpi_u8;
+typedef uint16_t uacpi_u16;
+typedef uint32_t uacpi_u32;
+typedef uint64_t uacpi_u64;
+
+typedef int8_t uacpi_i8;
+typedef int16_t uacpi_i16;
+typedef int32_t uacpi_i32;
+typedef int64_t uacpi_i64;
+
+#define UACPI_TRUE true
+#define UACPI_FALSE false
+typedef bool uacpi_bool;
+
+#define UACPI_NULL NULL
+
+typedef uintptr_t uacpi_uintptr;
+typedef uacpi_uintptr uacpi_virt_addr;
+typedef size_t uacpi_size;
+
+typedef va_list uacpi_va_list;
+#define uacpi_va_start va_start
+#define uacpi_va_end va_end
+#define uacpi_va_arg va_arg
+
+typedef char uacpi_char;
+
+#define uacpi_offsetof offsetof
+
+/*
+ * We use unsignd long long for 64-bit number formatting because 64-bit types
+ * don't have a standard way to format them. The inttypes.h header is not
+ * freestanding therefore it's not practical to force the user to define the
+ * corresponding PRI macros. Moreover, unsignd long long  is required to be
+ * at least 64-bits as per C99.
+ */
+UACPI_BUILD_BUG_ON_WITH_MSG(
+    sizeof(unsigned long long) < 8,
+    "unsigned long long must be at least 64 bits large as per C99"
+);
+#define UACPI_PRIu64 "llu"
+#define UACPI_PRIx64 "llx"
+#define UACPI_PRIX64 "llX"
+#define UACPI_FMT64(val) ((unsigned long long)(val))
+
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/registers.h

@@ -0,0 +1,105 @@
+#include <uacpi/types.h>
+
+/*
+ * BEFORE YOU USE THIS API:
+ * uACPI manages FADT registers on its own entirely, you should only use this
+ * API directly if there's absolutely no other way for your use case, e.g.
+ * implementing a CPU idle state driver that does C state switching or similar.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_register {
+    UACPI_REGISTER_PM1_STS = 0,
+    UACPI_REGISTER_PM1_EN,
+    UACPI_REGISTER_PM1_CNT,
+    UACPI_REGISTER_PM_TMR,
+    UACPI_REGISTER_PM2_CNT,
+    UACPI_REGISTER_SLP_CNT,
+    UACPI_REGISTER_SLP_STS,
+    UACPI_REGISTER_RESET,
+    UACPI_REGISTER_SMI_CMD,
+    UACPI_REGISTER_MAX = UACPI_REGISTER_SMI_CMD,
+} uacpi_register;
+
+/*
+ * Read a register from FADT
+ *
+ * NOTE: write-only bits (if any) are cleared automatically
+ */
+uacpi_status uacpi_read_register(uacpi_register, uacpi_u64*);
+
+/*
+ * Write a register from FADT
+ *
+ * NOTE:
+ * - Preserved bits (if any) are preserved automatically
+ * - If a register is made up of two (e.g. PM1a and PM1b) parts, the input
+ *   is written to both at the same time
+ */
+uacpi_status uacpi_write_register(uacpi_register, uacpi_u64);
+
+/*
+ * Write a register from FADT
+ *
+ * NOTE:
+ * - Preserved bits (if any) are preserved automatically
+ * - For registers that are made up of two (e.g. PM1a and PM1b) parts, the
+ *   provided values are written to their respective physical register
+ */
+uacpi_status uacpi_write_registers(uacpi_register, uacpi_u64, uacpi_u64);
+
+typedef enum uacpi_register_field {
+    UACPI_REGISTER_FIELD_TMR_STS = 0,
+    UACPI_REGISTER_FIELD_BM_STS,
+    UACPI_REGISTER_FIELD_GBL_STS,
+    UACPI_REGISTER_FIELD_PWRBTN_STS,
+    UACPI_REGISTER_FIELD_SLPBTN_STS,
+    UACPI_REGISTER_FIELD_RTC_STS,
+    UACPI_REGISTER_FIELD_PCIEX_WAKE_STS,
+    UACPI_REGISTER_FIELD_HWR_WAK_STS,
+    UACPI_REGISTER_FIELD_WAK_STS,
+    UACPI_REGISTER_FIELD_TMR_EN,
+    UACPI_REGISTER_FIELD_GBL_EN,
+    UACPI_REGISTER_FIELD_PWRBTN_EN,
+    UACPI_REGISTER_FIELD_SLPBTN_EN,
+    UACPI_REGISTER_FIELD_RTC_EN,
+    UACPI_REGISTER_FIELD_PCIEXP_WAKE_DIS,
+    UACPI_REGISTER_FIELD_SCI_EN,
+    UACPI_REGISTER_FIELD_BM_RLD,
+    UACPI_REGISTER_FIELD_GBL_RLS,
+    UACPI_REGISTER_FIELD_SLP_TYP,
+    UACPI_REGISTER_FIELD_HWR_SLP_TYP,
+    UACPI_REGISTER_FIELD_SLP_EN,
+    UACPI_REGISTER_FIELD_HWR_SLP_EN,
+    UACPI_REGISTER_FIELD_ARB_DIS,
+    UACPI_REGISTER_FIELD_MAX = UACPI_REGISTER_FIELD_ARB_DIS,
+} uacpi_register_field;
+
+/*
+ * Read a field from a FADT register
+ *
+ * NOTE: The value is automatically masked and shifted down as appropriate,
+ *       the client code doesn't have to do any bit manipulation. E.g. for
+ *       a field at 0b???XX??? the returned value will contain just the 0bXX
+ */
+uacpi_status uacpi_read_register_field(uacpi_register_field, uacpi_u64*);
+
+/*
+ * Write to a field of a FADT register
+ *
+ * NOTE: The value is automatically masked and shifted up as appropriate,
+ *       the client code doesn't have to do any bit manipulation. E.g. for
+ *       a field at 0b???XX??? the passed value should be just 0bXX
+ */
+uacpi_status uacpi_write_register_field(uacpi_register_field, uacpi_u64);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/resources.h

@@ -0,0 +1,734 @@
+#pragma once
+
+#include <uacpi/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_resource_type {
+    UACPI_RESOURCE_TYPE_IRQ,
+    UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
+
+    UACPI_RESOURCE_TYPE_DMA,
+    UACPI_RESOURCE_TYPE_FIXED_DMA,
+
+    UACPI_RESOURCE_TYPE_IO,
+    UACPI_RESOURCE_TYPE_FIXED_IO,
+
+    UACPI_RESOURCE_TYPE_ADDRESS16,
+    UACPI_RESOURCE_TYPE_ADDRESS32,
+    UACPI_RESOURCE_TYPE_ADDRESS64,
+    UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
+
+    UACPI_RESOURCE_TYPE_MEMORY24,
+    UACPI_RESOURCE_TYPE_MEMORY32,
+    UACPI_RESOURCE_TYPE_FIXED_MEMORY32,
+
+    UACPI_RESOURCE_TYPE_START_DEPENDENT,
+    UACPI_RESOURCE_TYPE_END_DEPENDENT,
+
+    // Up to 7 bytes
+    UACPI_RESOURCE_TYPE_VENDOR_SMALL,
+
+    // Up to 2^16 - 1 bytes
+    UACPI_RESOURCE_TYPE_VENDOR_LARGE,
+
+    UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
+    UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
+
+    // These must always be contiguous in this order
+    UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_SPI_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_UART_CONNECTION,
+    UACPI_RESOURCE_TYPE_SERIAL_CSI2_CONNECTION,
+
+    UACPI_RESOURCE_TYPE_PIN_FUNCTION,
+    UACPI_RESOURCE_TYPE_PIN_CONFIGURATION,
+    UACPI_RESOURCE_TYPE_PIN_GROUP,
+    UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION,
+    UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION,
+
+    UACPI_RESOURCE_TYPE_CLOCK_INPUT,
+
+    UACPI_RESOURCE_TYPE_END_TAG,
+    UACPI_RESOURCE_TYPE_MAX = UACPI_RESOURCE_TYPE_END_TAG,
+} uacpi_resource_type;
+
+typedef struct uacpi_resource_source {
+    uacpi_u8 index;
+    uacpi_bool index_present;
+    uacpi_u16 length;
+    uacpi_char *string;
+} uacpi_resource_source;
+
+/*
+ * This applies to IRQ & StartDependent resources only. The DONT_CARE value is
+ * used for deserialization into the AML format to signify that the serializer
+ * is allowed to optimize the length down if possible. Note that this is
+ * generally not allowed unless the resource is generated by the caller:
+ *
+ * -- ACPI 6.5 ------------------------------------------------------------
+ * The resource descriptors in the byte stream argument must be specified
+ * exactly as listed in the _CRS byte stream - meaning that the identical
+ * resource descriptors must appear in the identical order, resulting in a
+ * buffer of exactly the same length. Optimizations such as changing an
+ * IRQ descriptor to an IRQNoFlags descriptor (or vice-versa) must not be
+ * performed. Similarly, changing StartDependentFn to StartDependentFnNoPri
+ * is not allowed.
+ * ------------------------------------------------------------------------
+ */
+enum uacpi_resource_length_kind {
+    UACPI_RESOURCE_LENGTH_KIND_DONT_CARE = 0,
+    UACPI_RESOURCE_LENGTH_KIND_ONE_LESS,
+    UACPI_RESOURCE_LENGTH_KIND_FULL,
+};
+
+// triggering fields
+#define UACPI_TRIGGERING_EDGE 1
+#define UACPI_TRIGGERING_LEVEL 0
+
+// polarity
+#define UACPI_POLARITY_ACTIVE_HIGH 0
+#define UACPI_POLARITY_ACTIVE_LOW 1
+#define UACPI_POLARITY_ACTIVE_BOTH 2
+
+// sharing
+#define UACPI_EXCLUSIVE 0
+#define UACPI_SHARED 1
+
+// wake_capability
+#define UACPI_WAKE_CAPABLE 1
+#define UACPI_NOT_WAKE_CAPABLE 0
+
+typedef struct uacpi_resource_irq {
+    uacpi_u8 length_kind;
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+    uacpi_u8 num_irqs;
+    uacpi_u8 irqs[];
+} uacpi_resource_irq;
+
+typedef struct uacpi_resource_extended_irq {
+    uacpi_u8 direction;
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+    uacpi_u8 num_irqs;
+    uacpi_resource_source source;
+    uacpi_u32 irqs[];
+} uacpi_resource_extended_irq;
+
+// transfer_type
+#define UACPI_TRANSFER_TYPE_8_BIT 0b00
+#define UACPI_TRANSFER_TYPE_8_AND_16_BIT 0b01
+#define UACPI_TRANSFER_TYPE_16_BIT 0b10
+
+// bus_master_status
+#define UACPI_BUS_MASTER 0b1
+
+// channel_speed
+#define UACPI_DMA_COMPATIBILITY 0b00
+#define UACPI_DMA_TYPE_A 0b01
+#define UACPI_DMA_TYPE_B 0b10
+#define UACPI_DMA_TYPE_F 0b11
+
+// transfer_width
+#define UACPI_TRANSFER_WIDTH_8 0x00
+#define UACPI_TRANSFER_WIDTH_16 0x01
+#define UACPI_TRANSFER_WIDTH_32 0x02
+#define UACPI_TRANSFER_WIDTH_64 0x03
+#define UACPI_TRANSFER_WIDTH_128 0x04
+#define UACPI_TRANSFER_WIDTH_256 0x05
+
+typedef struct uacpi_resource_dma {
+    uacpi_u8 transfer_type;
+    uacpi_u8 bus_master_status;
+    uacpi_u8 channel_speed;
+    uacpi_u8 num_channels;
+    uacpi_u8 channels[];
+} uacpi_resource_dma;
+
+typedef struct uacpi_resource_fixed_dma {
+    uacpi_u16 request_line;
+    uacpi_u16 channel;
+    uacpi_u8 transfer_width;
+} uacpi_resource_fixed_dma;
+
+// decode_type
+#define UACPI_DECODE_16 0b1
+#define UACPI_DECODE_10 0b0
+
+typedef struct uacpi_resource_io {
+    uacpi_u8 decode_type;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u8 alignment;
+    uacpi_u8 length;
+} uacpi_resource_io;
+
+typedef struct uacpi_resource_fixed_io {
+    uacpi_u16 address;
+    uacpi_u8 length;
+} uacpi_resource_fixed_io;
+
+// write_status
+#define UACPI_NON_WRITABLE 0
+#define UACPI_WRITABLE 1
+
+// caching
+#define UACPI_NON_CACHEABLE 0
+#define UACPI_CACHEABLE 1
+#define UACPI_CACHEABLE_WRITE_COMBINING 2
+#define UACPI_PREFETCHABLE 3
+
+// range_type
+#define UACPI_RANGE_TYPE_MEMORY 0
+#define UACPI_RANGE_TYPE_RESERVED 1
+#define UACPI_RANGE_TYPE_ACPI 2
+#define UACPI_RANGE_TYPE_NVS 3
+
+// address_common->type
+#define UACPI_RANGE_MEMORY 0
+#define UACPI_RANGE_IO 1
+#define UACPI_RANGE_BUS 2
+
+// translation
+#define UACPI_IO_MEM_TRANSLATION 1
+#define UACPI_IO_MEM_STATIC 0
+
+// translation_type
+#define UACPI_TRANSLATION_DENSE 0
+#define UACPI_TRANSLATION_SPARSE 1
+
+// direction
+#define UACPI_PRODUCER 0
+#define UACPI_CONSUMER 1
+
+// decode_type
+#define UACPI_POISITIVE_DECODE 0
+#define UACPI_SUBTRACTIVE_DECODE 1
+
+// fixed_min_address & fixed_max_address
+#define UACPI_ADDRESS_NOT_FIXED 0
+#define UACPI_ADDRESS_FIXED 1
+
+typedef struct uacpi_memory_attribute {
+    uacpi_u8 write_status;
+    uacpi_u8 caching;
+    uacpi_u8 range_type;
+    uacpi_u8 translation;
+} uacpi_memory_attribute;
+
+typedef struct uacpi_io_attribute {
+    uacpi_u8 range_type;
+    uacpi_u8 translation;
+    uacpi_u8 translation_type;
+} uacpi_io_attribute;
+
+typedef union uacpi_address_attribute {
+    uacpi_memory_attribute memory;
+    uacpi_io_attribute io;
+    uacpi_u8 type_specific;
+} uacpi_address_attribute;
+
+typedef struct uacpi_resource_address_common {
+    uacpi_address_attribute attribute;
+    uacpi_u8 type;
+    uacpi_u8 direction;
+    uacpi_u8 decode_type;
+    uacpi_u8 fixed_min_address;
+    uacpi_u8 fixed_max_address;
+} uacpi_resource_address_common;
+
+typedef struct uacpi_resource_address16 {
+    uacpi_resource_address_common common;
+    uacpi_u16 granularity;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u16 translation_offset;
+    uacpi_u16 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address16;
+
+typedef struct uacpi_resource_address32 {
+    uacpi_resource_address_common common;
+    uacpi_u32 granularity;
+    uacpi_u32 minimum;
+    uacpi_u32 maximum;
+    uacpi_u32 translation_offset;
+    uacpi_u32 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address32;
+
+typedef struct uacpi_resource_address64 {
+    uacpi_resource_address_common common;
+    uacpi_u64 granularity;
+    uacpi_u64 minimum;
+    uacpi_u64 maximum;
+    uacpi_u64 translation_offset;
+    uacpi_u64 address_length;
+    uacpi_resource_source source;
+} uacpi_resource_address64;
+
+typedef struct uacpi_resource_address64_extended {
+    uacpi_resource_address_common common;
+    uacpi_u8 revision_id;
+    uacpi_u64 granularity;
+    uacpi_u64 minimum;
+    uacpi_u64 maximum;
+    uacpi_u64 translation_offset;
+    uacpi_u64 address_length;
+    uacpi_u64 attributes;
+} uacpi_resource_address64_extended;
+
+typedef struct uacpi_resource_memory24 {
+    uacpi_u8 write_status;
+    uacpi_u16 minimum;
+    uacpi_u16 maximum;
+    uacpi_u16 alignment;
+    uacpi_u16 length;
+} uacpi_resource_memory24;
+
+typedef struct uacpi_resource_memory32 {
+    uacpi_u8 write_status;
+    uacpi_u32 minimum;
+    uacpi_u32 maximum;
+    uacpi_u32 alignment;
+    uacpi_u32 length;
+} uacpi_resource_memory32;
+
+typedef struct uacpi_resource_fixed_memory32 {
+    uacpi_u8 write_status;
+    uacpi_u32 address;
+    uacpi_u32 length;
+} uacpi_resource_fixed_memory32;
+
+// compatibility & performance
+#define UACPI_GOOD 0
+#define UACPI_ACCEPTABLE 1
+#define UACPI_SUB_OPTIMAL 2
+
+typedef struct uacpi_resource_start_dependent {
+    uacpi_u8 length_kind;
+    uacpi_u8 compatibility;
+    uacpi_u8 performance;
+} uacpi_resource_start_dependent;
+
+typedef struct uacpi_resource_vendor_defined {
+    uacpi_u8 length;
+    uacpi_u8 data[];
+} uacpi_resource_vendor;
+
+typedef struct uacpi_resource_vendor_typed {
+    uacpi_u16 length;
+    uacpi_u8 sub_type;
+    uacpi_u8 uuid[16];
+    uacpi_u8 data[];
+} uacpi_resource_vendor_typed;
+
+typedef struct uacpi_resource_generic_register {
+    uacpi_u8 address_space_id;
+    uacpi_u8 bit_width;
+    uacpi_u8 bit_offset;
+    uacpi_u8 access_size;
+    uacpi_u64 address;
+} uacpi_resource_generic_register;
+
+// type
+#define UACPI_GPIO_CONNECTION_INTERRUPT 0x00
+#define UACPI_GPIO_CONNECTION_IO 0x01
+
+typedef struct uacpi_interrupt_connection_flags {
+    uacpi_u8 triggering;
+    uacpi_u8 polarity;
+    uacpi_u8 sharing;
+    uacpi_u8 wake_capability;
+} uacpi_interrupt_connection_flags;
+
+// restriction
+#define UACPI_IO_RESTRICTION_NONE 0x0
+#define UACPI_IO_RESTRICTION_INPUT 0x1
+#define UACPI_IO_RESTRICTION_OUTPUT 0x2
+#define UACPI_IO_RESTRICTION_NONE_PRESERVE 0x3
+
+typedef struct uacpi_io_connection_flags {
+    uacpi_u8 restriction;
+    uacpi_u8 sharing;
+} uacpi_io_connection_flags;
+
+// pull_configuration
+#define UACPI_PIN_CONFIG_DEFAULT 0x00
+#define UACPI_PIN_CONFIG_PULL_UP 0x01
+#define UACPI_PIN_CONFIG_PULL_DOWN 0x02
+#define UACPI_PIN_CONFIG_NO_PULL 0x03
+
+typedef struct uacpi_resource_gpio_connection {
+    uacpi_u8 revision_id;
+    uacpi_u8 type;
+    uacpi_u8 direction;
+
+    union {
+        uacpi_interrupt_connection_flags interrupt;
+        uacpi_io_connection_flags io;
+        uacpi_u16 type_specific;
+    };
+
+    uacpi_u8 pull_configuration;
+    uacpi_u16 drive_strength;
+    uacpi_u16 debounce_timeout;
+    uacpi_u16 vendor_data_length;
+    uacpi_u16 pin_table_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_gpio_connection;
+
+// mode
+#define UACPI_MODE_CONTROLLER_INITIATED 0x0
+#define UACPI_MODE_DEVICE_INITIATED 0x1
+
+typedef struct uacpi_resource_serial_bus_common {
+    uacpi_u8 revision_id;
+    uacpi_u8 type;
+    uacpi_u8 mode;
+    uacpi_u8 direction;
+    uacpi_u8 sharing;
+    uacpi_u8 type_revision_id;
+    uacpi_u16 type_data_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_serial_bus_common;
+
+// addressing_mode
+#define UACPI_I2C_7BIT 0x0
+#define UACPI_I2C_10BIT 0x1
+
+typedef struct uacpi_resource_i2c_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 addressing_mode;
+    uacpi_u16 slave_address;
+    uacpi_u32 connection_speed;
+} uacpi_resource_i2c_connection;
+
+// wire_mode
+#define UACPI_SPI_4_WIRES 0
+#define UACPI_SPI_3_WIRES 1
+
+// device_polarity
+#define UACPI_SPI_ACTIVE_LOW 0
+#define UACPI_SPI_ACTIVE_HIGH 1
+
+// phase
+#define UACPI_SPI_PHASE_FIRST 0
+#define UACPI_SPI_PHASE_SECOND 1
+
+// polarity
+#define UACPI_SPI_START_LOW 0
+#define UACPI_SPI_START_HIGH 1
+
+typedef struct uacpi_resource_spi_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 wire_mode;
+    uacpi_u8 device_polarity;
+    uacpi_u8 data_bit_length;
+    uacpi_u8 phase;
+    uacpi_u8 polarity;
+    uacpi_u16 device_selection;
+    uacpi_u32 connection_speed;
+} uacpi_resource_spi_connection;
+
+// stop_bits
+#define UACPI_UART_STOP_BITS_NONE 0b00
+#define UACPI_UART_STOP_BITS_1 0b01
+#define UACPI_UART_STOP_BITS_1_5 0b10
+#define UACPI_UART_STOP_BITS_2 0b11
+
+// data_bits
+#define UACPI_UART_DATA_5BITS 0b000
+#define UACPI_UART_DATA_6BITS 0b001
+#define UACPI_UART_DATA_7BITS 0b010
+#define UACPI_UART_DATA_8BITS 0b011
+#define UACPI_UART_DATA_9BITS 0b100
+
+// endianness
+#define UACPI_UART_LITTLE_ENDIAN 0
+#define UACPI_UART_BIG_ENDIAN 1
+
+// parity
+#define UACPI_UART_PARITY_NONE 0x00
+#define UACPI_UART_PARITY_EVEN 0x01
+#define UACPI_UART_PARITY_ODD 0x02
+#define UACPI_UART_PARITY_MARK 0x03
+#define UACPI_UART_PARITY_SPACE 0x04
+
+// lines_enabled
+#define UACPI_UART_DATA_CARRIER_DETECT (1 << 2)
+#define UACPI_UART_RING_INDICATOR (1 << 3)
+#define UACPI_UART_DATA_SET_READY (1 << 4)
+#define UACPI_UART_DATA_TERMINAL_READY (1 << 5)
+#define UACPI_UART_CLEAR_TO_SEND (1 << 6)
+#define UACPI_UART_REQUEST_TO_SEND (1 << 7)
+
+// flow_control
+#define UACPI_UART_FLOW_CONTROL_NONE 0b00
+#define UACPI_UART_FLOW_CONTROL_HW 0b01
+#define UACPI_UART_FLOW_CONTROL_XON_XOFF 0b10
+
+typedef struct uacpi_resource_uart_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 stop_bits;
+    uacpi_u8 data_bits;
+    uacpi_u8 endianness;
+    uacpi_u8 parity;
+    uacpi_u8 lines_enabled;
+    uacpi_u8 flow_control;
+    uacpi_u32 baud_rate;
+    uacpi_u16 rx_fifo;
+    uacpi_u16 tx_fifo;
+} uacpi_resource_uart_connection;
+
+// phy_type
+#define UACPI_CSI2_PHY_C 0b00
+#define UACPI_CSI2_PHY_D 0b01
+
+typedef struct uacpi_resource_csi2_connection {
+    uacpi_resource_serial_bus_common common;
+    uacpi_u8 phy_type;
+    uacpi_u8 local_port;
+} uacpi_resource_csi2_connection;
+
+typedef struct uacpi_resource_pin_function {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 pull_configuration;
+    uacpi_u16 function_number;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_function;
+
+// type
+#define UACPI_PIN_CONFIG_DEFAULT 0x00
+#define UACPI_PIN_CONFIG_BIAS_PULL_UP 0x01
+#define UACPI_PIN_CONFIG_BIAS_PULL_DOWN 0x02
+#define UACPI_PIN_CONFIG_BIAS_DEFAULT 0x03
+#define UACPI_PIN_CONFIG_BIAS_DISABLE 0x04
+#define UACPI_PIN_CONFIG_BIAS_HIGH_IMPEDANCE 0x05
+#define UACPI_PIN_CONFIG_BIAS_BUS_HOLD 0x06
+#define UACPI_PIN_CONFIG_DRIVE_OPEN_DRAIN 0x07
+#define UACPI_PIN_CONFIG_DRIVE_OPEN_SOURCE 0x08
+#define UACPI_PIN_CONFIG_DRIVE_PUSH_PULL 0x09
+#define UACPI_PIN_CONFIG_DRIVE_STRENGTH 0x0A
+#define UACPI_PIN_CONFIG_SLEW_RATE 0x0B
+#define UACPI_PIN_CONFIG_INPUT_DEBOUNCE 0x0C
+#define UACPI_PIN_CONFIG_INPUT_SCHMITT_TRIGGER 0x0D
+
+typedef struct uacpi_resource_pin_configuration {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u8 type;
+    uacpi_u32 value;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_configuration;
+
+typedef struct uacpi_resource_label {
+    uacpi_u16 length;
+    const uacpi_char *string;
+} uacpi_resource_label;
+
+typedef struct uacpi_resource_pin_group {
+    uacpi_u8 revision_id;
+    uacpi_u8 direction;
+    uacpi_u16 pin_table_length;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_label label;
+    uacpi_u16 *pin_table;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group;
+
+typedef struct uacpi_resource_pin_group_function {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u16 function;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_resource_label label;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group_function;
+
+typedef struct uacpi_resource_pin_group_configuration {
+    uacpi_u8 revision_id;
+    uacpi_u8 sharing;
+    uacpi_u8 direction;
+    uacpi_u8 type;
+    uacpi_u32 value;
+    uacpi_u16 vendor_data_length;
+    uacpi_resource_source source;
+    uacpi_resource_label label;
+    uacpi_u8 *vendor_data;
+} uacpi_resource_pin_group_configuration;
+
+// scale
+#define UACPI_SCALE_HZ 0b00
+#define UACPI_SCALE_KHZ 0b01
+#define UACPI_SCALE_MHZ 0b10
+
+// frequency
+#define UACPI_FREQUENCY_FIXED 0x0
+#define UACPI_FREQUENCY_VARIABLE 0x1
+
+typedef struct uacpi_resource_clock_input {
+    uacpi_u8 revision_id;
+    uacpi_u8 frequency;
+    uacpi_u8 scale;
+    uacpi_u16 divisor;
+    uacpi_u32 numerator;
+    uacpi_resource_source source;
+} uacpi_resource_clock_input;
+
+typedef struct uacpi_resource {
+    uacpi_u32 type;
+    uacpi_u32 length;
+
+    union {
+        uacpi_resource_irq irq;
+        uacpi_resource_extended_irq extended_irq;
+        uacpi_resource_dma dma;
+        uacpi_resource_fixed_dma fixed_dma;
+        uacpi_resource_io io;
+        uacpi_resource_fixed_io fixed_io;
+        uacpi_resource_address16 address16;
+        uacpi_resource_address32 address32;
+        uacpi_resource_address64 address64;
+        uacpi_resource_address64_extended address64_extended;
+        uacpi_resource_memory24 memory24;
+        uacpi_resource_memory32 memory32;
+        uacpi_resource_fixed_memory32 fixed_memory32;
+        uacpi_resource_start_dependent start_dependent;
+        uacpi_resource_vendor vendor;
+        uacpi_resource_vendor_typed vendor_typed;
+        uacpi_resource_generic_register generic_register;
+        uacpi_resource_gpio_connection gpio_connection;
+        uacpi_resource_serial_bus_common serial_bus_common;
+        uacpi_resource_i2c_connection i2c_connection;
+        uacpi_resource_spi_connection spi_connection;
+        uacpi_resource_uart_connection uart_connection;
+        uacpi_resource_csi2_connection csi2_connection;
+        uacpi_resource_pin_function pin_function;
+        uacpi_resource_pin_configuration pin_configuration;
+        uacpi_resource_pin_group pin_group;
+        uacpi_resource_pin_group_function pin_group_function;
+        uacpi_resource_pin_group_configuration pin_group_configuration;
+        uacpi_resource_clock_input clock_input;
+    };
+} uacpi_resource;
+
+#define UACPI_NEXT_RESOURCE(cur) \
+    ((uacpi_resource*)((uacpi_u8*)(cur) + (cur)->length))
+
+typedef struct uacpi_resources {
+    uacpi_size length;
+    uacpi_resource *entries;
+} uacpi_resources;
+void uacpi_free_resources(uacpi_resources*);
+
+typedef uacpi_iteration_decision (*uacpi_resource_iteration_callback)
+    (void *user, uacpi_resource *resource);
+
+/*
+ * Evaluate the _CRS method for a 'device' and get the returned resource list
+ * via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via a uacpi_free_resources()
+ */
+uacpi_status uacpi_get_current_resources(
+    uacpi_namespace_node *device, uacpi_resources **out_resources
+);
+
+/*
+ * Evaluate the _PRS method for a 'device' and get the returned resource list
+ * via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resources()
+ */
+uacpi_status uacpi_get_possible_resources(
+    uacpi_namespace_node *device, uacpi_resources **out_resources
+);
+
+/*
+ * Evaluate an arbitrary method that is expected to return an AML resource
+ * buffer for a 'device' and get the returned resource list via 'out_resources'.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resources()
+ */
+uacpi_status uacpi_get_device_resources(
+    uacpi_namespace_node *device, const uacpi_char *method,
+    uacpi_resources **out_resources
+);
+
+/*
+ * Set the configuration to be used by the 'device' by calling its _SRS method.
+ *
+ * Note that this expects 'resources' in the normal 'uacpi_resources' format,
+ * and not the raw AML resources bytestream, the conversion to the latter is
+ * done automatically by this API. If you want to _SRS a raw AML resources
+ * bytestream, use 'uacpi_execute' or similar API directly.
+ */
+uacpi_status uacpi_set_resources(
+    uacpi_namespace_node *device, uacpi_resources *resources
+);
+
+/*
+ * A convenience helper for iterating over the resource list returned by any
+ * of the uacpi_get_*_resources functions.
+ */
+uacpi_status uacpi_for_each_resource(
+    uacpi_resources *resources, uacpi_resource_iteration_callback cb, void *user
+);
+
+/*
+ * A shorthand for uacpi_get_device_resources() + uacpi_for_each_resource().
+ *
+ * Use if you don't actually want to save the 'resources' list, but simply want
+ * to iterate it once to extract the resources you care about and then free it
+ * right away.
+ */
+uacpi_status uacpi_for_each_device_resource(
+    uacpi_namespace_node *device, const uacpi_char *method,
+    uacpi_resource_iteration_callback cb, void *user
+);
+
+/*
+ * Convert a single AML-encoded resource to native format.
+ *
+ * This should be used for converting Connection() fields (passed during IO on
+ * GeneralPurposeIO or GenericSerialBus operation regions) or other similar
+ * buffers with only one resource to native format.
+ *
+ * NOTE: the returned buffer must be released via uacpi_free_resource()
+ */
+uacpi_status uacpi_get_resource_from_buffer(
+    uacpi_data_view aml_buffer, uacpi_resource **out_resource
+);
+void uacpi_free_resource(uacpi_resource*);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/sleep.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/uacpi.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Set the firmware waking vector in FACS.
+ *
+ * 'addr32' is the real mode entry-point address
+ * 'addr64' is the protected mode entry-point address
+ */
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+uacpi_status uacpi_set_waking_vector(
+    uacpi_phys_addr addr32, uacpi_phys_addr addr64
+))
+
+typedef enum uacpi_sleep_state {
+    UACPI_SLEEP_STATE_S0 = 0,
+    UACPI_SLEEP_STATE_S1,
+    UACPI_SLEEP_STATE_S2,
+    UACPI_SLEEP_STATE_S3,
+    UACPI_SLEEP_STATE_S4,
+    UACPI_SLEEP_STATE_S5,
+    UACPI_SLEEP_STATE_MAX = UACPI_SLEEP_STATE_S5,
+} uacpi_sleep_state;
+
+/*
+ * Prepare for a given sleep state.
+ * Must be caled with interrupts ENABLED.
+ */
+uacpi_status uacpi_prepare_for_sleep_state(uacpi_sleep_state);
+
+/*
+ * Enter the given sleep state after preparation.
+ * Must be called with interrupts DISABLED.
+ */
+uacpi_status uacpi_enter_sleep_state(uacpi_sleep_state);
+
+/*
+ * Prepare to leave the given sleep state.
+ * Must be called with interrupts DISABLED.
+ */
+uacpi_status uacpi_prepare_for_wake_from_sleep_state(uacpi_sleep_state);
+
+/*
+ * Wake from the given sleep state.
+ * Must be called with interrupts ENABLED.
+ */
+uacpi_status uacpi_wake_from_sleep_state(uacpi_sleep_state);
+
+/*
+ * Attempt reset via the FADT reset register.
+ */
+uacpi_status uacpi_reboot(void);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/status.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <uacpi/internal/compiler.h>
+#include <uacpi/platform/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum uacpi_status {
+    UACPI_STATUS_OK = 0,
+    UACPI_STATUS_MAPPING_FAILED = 1,
+    UACPI_STATUS_OUT_OF_MEMORY = 2,
+    UACPI_STATUS_BAD_CHECKSUM = 3,
+    UACPI_STATUS_INVALID_SIGNATURE = 4,
+    UACPI_STATUS_INVALID_TABLE_LENGTH = 5,
+    UACPI_STATUS_NOT_FOUND = 6,
+    UACPI_STATUS_INVALID_ARGUMENT = 7,
+    UACPI_STATUS_UNIMPLEMENTED = 8,
+    UACPI_STATUS_ALREADY_EXISTS = 9,
+    UACPI_STATUS_INTERNAL_ERROR = 10,
+    UACPI_STATUS_TYPE_MISMATCH = 11,
+    UACPI_STATUS_INIT_LEVEL_MISMATCH = 12,
+    UACPI_STATUS_NAMESPACE_NODE_DANGLING = 13,
+    UACPI_STATUS_NO_HANDLER = 14,
+    UACPI_STATUS_NO_RESOURCE_END_TAG = 15,
+    UACPI_STATUS_COMPILED_OUT = 16,
+    UACPI_STATUS_HARDWARE_TIMEOUT = 17,
+    UACPI_STATUS_TIMEOUT = 18,
+    UACPI_STATUS_OVERRIDDEN = 19,
+    UACPI_STATUS_DENIED = 20,
+
+    // All errors that have bytecode-related origin should go here
+    UACPI_STATUS_AML_UNDEFINED_REFERENCE = 0x0EFF0000,
+    UACPI_STATUS_AML_INVALID_NAMESTRING = 0x0EFF0001,
+    UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS = 0x0EFF0002,
+    UACPI_STATUS_AML_INVALID_OPCODE = 0x0EFF0003,
+    UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE = 0x0EFF0004,
+    UACPI_STATUS_AML_BAD_ENCODING = 0x0EFF0005,
+    UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX = 0x0EFF0006,
+    UACPI_STATUS_AML_SYNC_LEVEL_TOO_HIGH = 0x0EFF0007,
+    UACPI_STATUS_AML_INVALID_RESOURCE = 0x0EFF0008,
+    UACPI_STATUS_AML_LOOP_TIMEOUT = 0x0EFF0009,
+    UACPI_STATUS_AML_CALL_STACK_DEPTH_LIMIT = 0x0EFF000A,
+} uacpi_status;
+
+const uacpi_char *uacpi_status_to_string(uacpi_status);
+
+#define uacpi_unlikely_error(expr) uacpi_unlikely((expr) != UACPI_STATUS_OK)
+#define uacpi_likely_error(expr)   uacpi_likely((expr) != UACPI_STATUS_OK)
+
+#define uacpi_unlikely_success(expr) uacpi_unlikely((expr) == UACPI_STATUS_OK)
+#define uacpi_likely_success(expr)   uacpi_likely((expr) == UACPI_STATUS_OK)
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/tables.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward-declared to avoid including the entire acpi.h here
+struct acpi_fadt;
+
+typedef struct uacpi_table_identifiers {
+    uacpi_object_name signature;
+
+    // if oemid[0] == 0 this field is ignored
+    char oemid[6];
+
+    // if oem_table_id[0] == 0 this field is ignored
+    char oem_table_id[8];
+} uacpi_table_identifiers;
+
+typedef struct uacpi_table {
+    union {
+        uacpi_virt_addr virt_addr;
+        void *ptr;
+        struct acpi_sdt_hdr *hdr;
+    };
+
+     // Index number used to identify this table internally
+    uacpi_size index;
+} uacpi_table;
+
+/*
+ * Install a table from either a virtual or a physical address.
+ * The table is simply stored in the internal table array, and not loaded by
+ * the interpreter (see uacpi_table_load).
+ *
+ * The table is optionally returned via 'out_table'.
+ *
+ * Manual calls to uacpi_table_install are not subject to filtering via the
+ * table installation callback (if any).
+ */
+uacpi_status uacpi_table_install(
+    void*, uacpi_table *out_table
+);
+uacpi_status uacpi_table_install_physical(
+    uacpi_phys_addr, uacpi_table *out_table
+);
+
+#ifndef UACPI_BAREBONES_MODE
+/*
+ * Load a previously installed table by feeding it to the interpreter.
+ */
+uacpi_status uacpi_table_load(uacpi_size index);
+#endif // !UACPI_BAREBONES_MODE
+
+/*
+ * Helpers for finding tables.
+ *
+ * NOTE:
+ * The returned table's reference count is incremented by 1, which keeps its
+ * mapping alive forever unless uacpi_table_unref() is called for this table
+ * later on. Calling uacpi_table_find_next_with_same_signature() on a table also
+ * drops its reference count by 1, so if you want to keep it mapped you must
+ * manually call uacpi_table_ref() beforehand.
+ */
+uacpi_status uacpi_table_find_by_signature(
+    const uacpi_char *signature, uacpi_table *out_table
+);
+uacpi_status uacpi_table_find_next_with_same_signature(
+    uacpi_table *in_out_table
+);
+uacpi_status uacpi_table_find(
+    const uacpi_table_identifiers *id, uacpi_table *out_table
+);
+
+/*
+ * Increment/decrement a table's reference count.
+ * The table is unmapped when the reference count drops to 0.
+ */
+uacpi_status uacpi_table_ref(uacpi_table*);
+uacpi_status uacpi_table_unref(uacpi_table*);
+
+/*
+ * Returns the pointer to a sanitized internal version of FADT.
+ *
+ * The revision is guaranteed to be correct. All of the registers are converted
+ * to GAS format. Fields that might contain garbage are cleared.
+ */
+uacpi_status uacpi_table_fadt(struct acpi_fadt**);
+
+typedef enum uacpi_table_installation_disposition {
+    // Allow the table to be installed as-is
+    UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW = 0,
+
+    /*
+     * Deny the table from being installed completely. This is useful for
+     * debugging various problems, e.g. AML loading bad SSDTs that cause the
+     * system to hang or enter an undesired state.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_DENY,
+
+    /*
+     * Override the table being installed with the table at the virtual address
+     * returned in 'out_override_address'.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_VIRTUAL_OVERRIDE,
+
+    /*
+     * Override the table being installed with the table at the physical address
+     * returned in 'out_override_address'.
+     */
+    UACPI_TABLE_INSTALLATION_DISPOSITON_PHYSICAL_OVERRIDE,
+} uacpi_table_installation_disposition;
+
+typedef uacpi_table_installation_disposition (*uacpi_table_installation_handler)
+    (struct acpi_sdt_hdr *hdr, uacpi_u64 *out_override_address);
+
+/*
+ * Set a handler that is invoked for each table before it gets installed.
+ *
+ * Depending on the return value, the table is either allowed to be installed
+ * as-is, denied, or overriden with a new one.
+ */
+uacpi_status uacpi_set_table_installation_handler(
+    uacpi_table_installation_handler handler
+);
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/types.h

@@ -0,0 +1,544 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/platform/types.h>
+#include <uacpi/platform/compiler.h>
+#include <uacpi/platform/arch_helpers.h>
+#include <uacpi/platform/config.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if UACPI_POINTER_SIZE == 4 && defined(UACPI_PHYS_ADDR_IS_32BITS)
+typedef uacpi_u32 uacpi_phys_addr;
+typedef uacpi_u32 uacpi_io_addr;
+#else
+typedef uacpi_u64 uacpi_phys_addr;
+typedef uacpi_u64 uacpi_io_addr;
+#endif
+
+typedef void *uacpi_handle;
+
+typedef union uacpi_object_name {
+    uacpi_char text[4];
+    uacpi_u32 id;
+} uacpi_object_name;
+
+typedef enum uacpi_iteration_decision {
+    UACPI_ITERATION_DECISION_CONTINUE = 0,
+    UACPI_ITERATION_DECISION_BREAK,
+
+    // Only applicable for uacpi_namespace_for_each_child
+    UACPI_ITERATION_DECISION_NEXT_PEER,
+} uacpi_iteration_decision;
+
+typedef enum uacpi_address_space {
+    UACPI_ADDRESS_SPACE_SYSTEM_MEMORY = 0,
+    UACPI_ADDRESS_SPACE_SYSTEM_IO = 1,
+    UACPI_ADDRESS_SPACE_PCI_CONFIG = 2,
+    UACPI_ADDRESS_SPACE_EMBEDDED_CONTROLLER = 3,
+    UACPI_ADDRESS_SPACE_SMBUS = 4,
+    UACPI_ADDRESS_SPACE_SYSTEM_CMOS = 5,
+    UACPI_ADDRESS_SPACE_PCI_BAR_TARGET = 6,
+    UACPI_ADDRESS_SPACE_IPMI = 7,
+    UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO = 8,
+    UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS = 9,
+    UACPI_ADDRESS_SPACE_PCC = 0x0A,
+    UACPI_ADDRESS_SPACE_PRM = 0x0B,
+    UACPI_ADDRESS_SPACE_FFIXEDHW = 0x7F,
+
+    // Internal type
+    UACPI_ADDRESS_SPACE_TABLE_DATA = 0xDA1A,
+} uacpi_address_space;
+const uacpi_char *uacpi_address_space_to_string(uacpi_address_space space);
+
+#ifndef UACPI_BAREBONES_MODE
+
+typedef enum uacpi_init_level {
+    // Reboot state, nothing is available
+    UACPI_INIT_LEVEL_EARLY = 0,
+
+    /*
+     * State after a successfull call to uacpi_initialize. Table API and
+     * other helpers that don't depend on the ACPI namespace may be used.
+     */
+    UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED = 1,
+
+    /*
+     * State after a successfull call to uacpi_namespace_load. Most API may be
+     * used, namespace can be iterated, etc.
+     */
+    UACPI_INIT_LEVEL_NAMESPACE_LOADED = 2,
+
+    /*
+     * The final initialization stage, this is entered after the call to
+     * uacpi_namespace_initialize. All API is available to use.
+     */
+    UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED = 3,
+} uacpi_init_level;
+
+typedef struct uacpi_pci_address {
+    uacpi_u16 segment;
+    uacpi_u8 bus;
+    uacpi_u8 device;
+    uacpi_u8 function;
+} uacpi_pci_address;
+
+typedef struct uacpi_data_view {
+    union {
+        uacpi_u8 *bytes;
+        const uacpi_u8 *const_bytes;
+
+        uacpi_char *text;
+        const uacpi_char *const_text;
+
+        void *data;
+        const void *const_data;
+    };
+    uacpi_size length;
+} uacpi_data_view;
+
+typedef struct uacpi_namespace_node uacpi_namespace_node;
+
+typedef enum uacpi_object_type {
+    UACPI_OBJECT_UNINITIALIZED = 0,
+    UACPI_OBJECT_INTEGER = 1,
+    UACPI_OBJECT_STRING = 2,
+    UACPI_OBJECT_BUFFER = 3,
+    UACPI_OBJECT_PACKAGE = 4,
+    UACPI_OBJECT_FIELD_UNIT = 5,
+    UACPI_OBJECT_DEVICE = 6,
+    UACPI_OBJECT_EVENT = 7,
+    UACPI_OBJECT_METHOD = 8,
+    UACPI_OBJECT_MUTEX = 9,
+    UACPI_OBJECT_OPERATION_REGION = 10,
+    UACPI_OBJECT_POWER_RESOURCE = 11,
+    UACPI_OBJECT_PROCESSOR = 12,
+    UACPI_OBJECT_THERMAL_ZONE = 13,
+    UACPI_OBJECT_BUFFER_FIELD = 14,
+    UACPI_OBJECT_DEBUG = 16,
+
+    UACPI_OBJECT_REFERENCE = 20,
+    UACPI_OBJECT_BUFFER_INDEX = 21,
+    UACPI_OBJECT_MAX_TYPE_VALUE = UACPI_OBJECT_BUFFER_INDEX
+} uacpi_object_type;
+
+// Type bits for API requiring a bit mask, e.g. uacpi_eval_typed
+typedef enum uacpi_object_type_bits {
+    UACPI_OBJECT_INTEGER_BIT = (1 << UACPI_OBJECT_INTEGER),
+    UACPI_OBJECT_STRING_BIT = (1 << UACPI_OBJECT_STRING),
+    UACPI_OBJECT_BUFFER_BIT = (1 << UACPI_OBJECT_BUFFER),
+    UACPI_OBJECT_PACKAGE_BIT = (1 << UACPI_OBJECT_PACKAGE),
+    UACPI_OBJECT_FIELD_UNIT_BIT = (1 << UACPI_OBJECT_FIELD_UNIT),
+    UACPI_OBJECT_DEVICE_BIT = (1 << UACPI_OBJECT_DEVICE),
+    UACPI_OBJECT_EVENT_BIT = (1 << UACPI_OBJECT_EVENT),
+    UACPI_OBJECT_METHOD_BIT = (1 << UACPI_OBJECT_METHOD),
+    UACPI_OBJECT_MUTEX_BIT = (1 << UACPI_OBJECT_MUTEX),
+    UACPI_OBJECT_OPERATION_REGION_BIT = (1 << UACPI_OBJECT_OPERATION_REGION),
+    UACPI_OBJECT_POWER_RESOURCE_BIT = (1 << UACPI_OBJECT_POWER_RESOURCE),
+    UACPI_OBJECT_PROCESSOR_BIT = (1 << UACPI_OBJECT_PROCESSOR),
+    UACPI_OBJECT_THERMAL_ZONE_BIT = (1 << UACPI_OBJECT_THERMAL_ZONE),
+    UACPI_OBJECT_BUFFER_FIELD_BIT = (1 << UACPI_OBJECT_BUFFER_FIELD),
+    UACPI_OBJECT_DEBUG_BIT = (1 << UACPI_OBJECT_DEBUG),
+    UACPI_OBJECT_REFERENCE_BIT = (1 << UACPI_OBJECT_REFERENCE),
+    UACPI_OBJECT_BUFFER_INDEX_BIT = (1 << UACPI_OBJECT_BUFFER_INDEX),
+    UACPI_OBJECT_ANY_BIT = 0xFFFFFFFF,
+} uacpi_object_type_bits;
+
+typedef struct uacpi_object uacpi_object;
+
+void uacpi_object_ref(uacpi_object *obj);
+void uacpi_object_unref(uacpi_object *obj);
+
+uacpi_object_type uacpi_object_get_type(uacpi_object*);
+uacpi_object_type_bits uacpi_object_get_type_bit(uacpi_object*);
+
+/*
+ * Returns UACPI_TRUE if the provided object's type matches this type.
+ */
+uacpi_bool uacpi_object_is(uacpi_object*, uacpi_object_type);
+
+/*
+ * Returns UACPI_TRUE if the provided object's type is one of the values
+ * specified in the 'type_mask' of UACPI_OBJECT_*_BIT.
+ */
+uacpi_bool uacpi_object_is_one_of(
+    uacpi_object*, uacpi_object_type_bits type_mask
+);
+
+const uacpi_char *uacpi_object_type_to_string(uacpi_object_type);
+
+/*
+ * Create an uninitialized object. The object can be further overwritten via
+ * uacpi_object_assign_* to anything.
+ */
+uacpi_object *uacpi_object_create_uninitialized(void);
+
+/*
+ * Create an integer object with the value provided.
+ */
+uacpi_object *uacpi_object_create_integer(uacpi_u64);
+
+typedef enum uacpi_overflow_behavior {
+    UACPI_OVERFLOW_ALLOW = 0,
+    UACPI_OVERFLOW_TRUNCATE,
+    UACPI_OVERFLOW_DISALLOW,
+} uacpi_overflow_behavior;
+
+/*
+ * Same as uacpi_object_create_integer, but introduces additional ways to
+ * control what happens if the provided integer is larger than 32-bits, and the
+ * AML code expects 32-bit integers.
+ *
+ * - UACPI_OVERFLOW_ALLOW -> do nothing, same as the vanilla helper
+ * - UACPI_OVERFLOW_TRUNCATE -> truncate the integer to 32-bits if it happens to
+ *                              be larger than allowed by the DSDT
+ * - UACPI_OVERFLOW_DISALLOW -> fail object creation with
+ *                              UACPI_STATUS_INVALID_ARGUMENT if the provided
+ *                              value happens to be too large
+ */
+uacpi_status uacpi_object_create_integer_safe(
+    uacpi_u64, uacpi_overflow_behavior, uacpi_object **out_obj
+);
+
+uacpi_status uacpi_object_assign_integer(uacpi_object*, uacpi_u64 value);
+uacpi_status uacpi_object_get_integer(uacpi_object*, uacpi_u64 *out);
+
+/*
+ * Create a string/buffer object. Takes in a constant view of the data.
+ *
+ * NOTE: The data is copied to a separately allocated buffer and is not taken
+ *       ownership of.
+ */
+uacpi_object *uacpi_object_create_string(uacpi_data_view);
+uacpi_object *uacpi_object_create_cstring(const uacpi_char*);
+uacpi_object *uacpi_object_create_buffer(uacpi_data_view);
+
+/*
+ * Returns a writable view of the data stored in the string or buffer type
+ * object.
+ */
+uacpi_status uacpi_object_get_string_or_buffer(
+    uacpi_object*, uacpi_data_view *out
+);
+uacpi_status uacpi_object_get_string(uacpi_object*, uacpi_data_view *out);
+uacpi_status uacpi_object_get_buffer(uacpi_object*, uacpi_data_view *out);
+
+/*
+ * Returns UACPI_TRUE if the provided string object is actually an AML namepath.
+ *
+ * This can only be the case for package elements. If a package element is
+ * specified as a path to an object in AML, it's not resolved by the interpreter
+ * right away as it might not have been defined at that point yet, and is
+ * instead stored as a special string object to be resolved by client code
+ * when needed.
+ *
+ * Example usage:
+ *     uacpi_namespace_node *target_node = UACPI_NULL;
+ *
+ *     uacpi_object *obj = UACPI_NULL;
+ *     uacpi_eval(scope, path, UACPI_NULL, &obj);
+ *
+ *     uacpi_object_array arr;
+ *     uacpi_object_get_package(obj, &arr);
+ *
+ *     if (uacpi_object_is_aml_namepath(arr.objects[0])) {
+ *         uacpi_object_resolve_as_aml_namepath(
+ *             arr.objects[0], scope, &target_node
+ *         );
+ *     }
+ */
+uacpi_bool uacpi_object_is_aml_namepath(uacpi_object*);
+
+/*
+ * Resolve an AML namepath contained in a string object.
+ *
+ * This is only applicable to objects that are package elements. See an
+ * explanation of how this works in the comment above the declaration of
+ * uacpi_object_is_aml_namepath.
+ *
+ * This is a shorthand for:
+ *     uacpi_data_view view;
+ *     uacpi_object_get_string(object, &view);
+ *
+ *     target_node = uacpi_namespace_node_resolve_from_aml_namepath(
+ *         scope, view.text
+ *     );
+ */
+uacpi_status uacpi_object_resolve_as_aml_namepath(
+    uacpi_object*, uacpi_namespace_node *scope, uacpi_namespace_node **out_node
+);
+
+/*
+ * Make the provided object a string/buffer.
+ * Takes in a constant view of the data to be stored in the object.
+ *
+ * NOTE: The data is copied to a separately allocated buffer and is not taken
+ *       ownership of.
+ */
+uacpi_status uacpi_object_assign_string(uacpi_object*, uacpi_data_view in);
+uacpi_status uacpi_object_assign_buffer(uacpi_object*, uacpi_data_view in);
+
+typedef struct uacpi_object_array {
+    uacpi_object **objects;
+    uacpi_size count;
+} uacpi_object_array;
+
+/*
+ * Create a package object and store all of the objects in the array inside.
+ * The array is allowed to be empty.
+ *
+ * NOTE: the reference count of each object is incremented before being stored
+ *       in the object. Client code must remove all of the locally created
+ *       references at its own discretion.
+ */
+uacpi_object *uacpi_object_create_package(uacpi_object_array in);
+
+/*
+ * Returns the list of objects stored in a package object.
+ *
+ * NOTE: the reference count of the objects stored inside is not incremented,
+ *       which means destorying/overwriting the object also potentially destroys
+ *       all of the objects stored inside unless the reference count is
+ *       incremented by the client via uacpi_object_ref.
+ */
+uacpi_status uacpi_object_get_package(uacpi_object*, uacpi_object_array *out);
+
+/*
+ * Make the provided object a package and store all of the objects in the array
+ * inside. The array is allowed to be empty.
+ *
+ * NOTE: the reference count of each object is incremented before being stored
+ *       in the object. Client code must remove all of the locally created
+ *       references at its own discretion.
+ */
+uacpi_status uacpi_object_assign_package(uacpi_object*, uacpi_object_array in);
+
+/*
+ * Create a reference object and make it point to 'child'.
+ *
+ * NOTE: child's reference count is incremented by one. Client code must remove
+ *       all of the locally created references at its own discretion.
+ */
+uacpi_object *uacpi_object_create_reference(uacpi_object *child);
+
+/*
+ * Make the provided object a reference and make it point to 'child'.
+ *
+ * NOTE: child's reference count is incremented by one. Client code must remove
+ *       all of the locally created references at its own discretion.
+ */
+uacpi_status uacpi_object_assign_reference(uacpi_object*, uacpi_object *child);
+
+/*
+ * Retrieve the object pointed to by a reference object.
+ *
+ * NOTE: the reference count of the returned object is incremented by one and
+ *       must be uacpi_object_unref'ed by the client when no longer needed.
+ */
+uacpi_status uacpi_object_get_dereferenced(uacpi_object*, uacpi_object **out);
+
+typedef struct uacpi_processor_info {
+    uacpi_u8 id;
+    uacpi_u32 block_address;
+    uacpi_u8 block_length;
+} uacpi_processor_info;
+
+/*
+ * Returns the information about the provided processor object.
+ */
+uacpi_status uacpi_object_get_processor_info(
+    uacpi_object*, uacpi_processor_info *out
+);
+
+typedef struct uacpi_power_resource_info {
+    uacpi_u8 system_level;
+    uacpi_u16 resource_order;
+} uacpi_power_resource_info;
+
+/*
+ * Returns the information about the provided power resource object.
+ */
+uacpi_status uacpi_object_get_power_resource_info(
+    uacpi_object*, uacpi_power_resource_info *out
+);
+
+typedef enum uacpi_region_op {
+    // data => uacpi_region_attach_data
+    UACPI_REGION_OP_ATTACH = 0,
+    // data => uacpi_region_detach_data
+    UACPI_REGION_OP_DETACH,
+
+    // data => uacpi_region_rw_data
+    UACPI_REGION_OP_READ,
+    UACPI_REGION_OP_WRITE,
+
+    // data => uacpi_region_pcc_send_data
+    UACPI_REGION_OP_PCC_SEND,
+
+    // data => uacpi_region_gpio_rw_data
+    UACPI_REGION_OP_GPIO_READ,
+    UACPI_REGION_OP_GPIO_WRITE,
+
+    // data => uacpi_region_ipmi_rw_data
+    UACPI_REGION_OP_IPMI_COMMAND,
+
+    // data => uacpi_region_ffixedhw_rw_data
+    UACPI_REGION_OP_FFIXEDHW_COMMAND,
+
+    // data => uacpi_region_prm_rw_data
+    UACPI_REGION_OP_PRM_COMMAND,
+
+    // data => uacpi_region_serial_rw_data
+    UACPI_REGION_OP_SERIAL_READ,
+    UACPI_REGION_OP_SERIAL_WRITE,
+} uacpi_region_op;
+
+typedef struct uacpi_generic_region_info {
+    uacpi_u64 base;
+    uacpi_u64 length;
+} uacpi_generic_region_info;
+
+typedef struct uacpi_pcc_region_info {
+    uacpi_data_view buffer;
+    uacpi_u8 subspace_id;
+} uacpi_pcc_region_info;
+
+typedef struct uacpi_gpio_region_info
+{
+    uacpi_u64 num_pins;
+} uacpi_gpio_region_info;
+
+typedef struct uacpi_region_attach_data {
+    void *handler_context;
+    uacpi_namespace_node *region_node;
+    union {
+        uacpi_generic_region_info generic_info;
+        uacpi_pcc_region_info pcc_info;
+        uacpi_gpio_region_info gpio_info;
+    };
+    void *out_region_context;
+} uacpi_region_attach_data;
+
+typedef struct uacpi_region_rw_data {
+    void *handler_context;
+    void *region_context;
+    union {
+        uacpi_phys_addr address;
+        uacpi_u64 offset;
+    };
+    uacpi_u64 value;
+    uacpi_u8 byte_width;
+} uacpi_region_rw_data;
+
+typedef struct uacpi_region_pcc_send_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view buffer;
+} uacpi_region_pcc_send_data;
+
+typedef struct uacpi_region_gpio_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view connection;
+    uacpi_u32 pin_offset;
+    uacpi_u32 num_pins;
+    uacpi_u64 value;
+} uacpi_region_gpio_rw_data;
+
+typedef struct uacpi_region_ipmi_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view in_out_message;
+    uacpi_u64 command;
+} uacpi_region_ipmi_rw_data;
+
+typedef uacpi_region_ipmi_rw_data uacpi_region_ffixedhw_rw_data;
+
+typedef struct uacpi_region_prm_rw_data
+{
+    void *handler_context;
+    void *region_context;
+    uacpi_data_view in_out_message;
+} uacpi_region_prm_rw_data;
+
+typedef enum uacpi_access_attribute {
+    UACPI_ACCESS_ATTRIBUTE_QUICK = 0x02,
+    UACPI_ACCESS_ATTRIBUTE_SEND_RECEIVE = 0x04,
+    UACPI_ACCESS_ATTRIBUTE_BYTE = 0x06,
+    UACPI_ACCESS_ATTRIBUTE_WORD = 0x08,
+    UACPI_ACCESS_ATTRIBUTE_BLOCK = 0x0A,
+    UACPI_ACCESS_ATTRIBUTE_BYTES = 0x0B,
+    UACPI_ACCESS_ATTRIBUTE_PROCESS_CALL = 0x0C,
+    UACPI_ACCESS_ATTRIBUTE_BLOCK_PROCESS_CALL = 0x0D,
+    UACPI_ACCESS_ATTRIBUTE_RAW_BYTES = 0x0E,
+    UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES = 0x0F,
+} uacpi_access_attribute;
+
+typedef struct uacpi_region_serial_rw_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_u64 command;
+    uacpi_data_view connection;
+    uacpi_data_view in_out_buffer;
+    uacpi_access_attribute access_attribute;
+
+    /*
+     * Applicable if access_attribute is one of:
+     * - UACPI_ACCESS_ATTRIBUTE_BYTES
+     * - UACPI_ACCESS_ATTRIBUTE_RAW_BYTES
+     * - UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES
+     */
+    uacpi_u8 access_length;
+} uacpi_region_serial_rw_data;
+
+typedef struct uacpi_region_detach_data {
+    void *handler_context;
+    void *region_context;
+    uacpi_namespace_node *region_node;
+} uacpi_region_detach_data;
+
+typedef uacpi_status (*uacpi_region_handler)
+    (uacpi_region_op op, uacpi_handle op_data);
+
+typedef uacpi_status (*uacpi_notify_handler)
+    (uacpi_handle context, uacpi_namespace_node *node, uacpi_u64 value);
+
+typedef enum uacpi_firmware_request_type {
+    UACPI_FIRMWARE_REQUEST_TYPE_BREAKPOINT,
+    UACPI_FIRMWARE_REQUEST_TYPE_FATAL,
+} uacpi_firmware_request_type;
+
+typedef struct uacpi_firmware_request {
+    uacpi_u8 type;
+
+    union {
+        // UACPI_FIRMWARE_REQUEST_BREAKPOINT
+        struct {
+            // The context of the method currently being executed
+            uacpi_handle ctx;
+        } breakpoint;
+
+        // UACPI_FIRMWARE_REQUEST_FATAL
+        struct {
+            uacpi_u8 type;
+            uacpi_u32 code;
+            uacpi_u64 arg;
+        } fatal;
+    };
+} uacpi_firmware_request;
+
+#define UACPI_INTERRUPT_NOT_HANDLED 0
+#define UACPI_INTERRUPT_HANDLED 1
+typedef uacpi_u32 uacpi_interrupt_ret;
+
+typedef uacpi_interrupt_ret (*uacpi_interrupt_handler)(uacpi_handle);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/uacpi.h

@@ -0,0 +1,269 @@
+#pragma once
+
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/namespace.h>
+
+#define UACPI_MAJOR 2
+#define UACPI_MINOR 1
+#define UACPI_PATCH 1
+
+#ifdef UACPI_REDUCED_HARDWARE
+#define UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, ret) \
+    UACPI_NO_UNUSED_PARAMETER_WARNINGS_BEGIN          \
+    static inline fn { return ret; }                \
+    UACPI_NO_UNUSED_PARAMETER_WARNINGS_END
+
+#define UACPI_STUB_IF_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn,)
+#define UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, UACPI_STATUS_COMPILED_OUT)
+#define UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(fn) \
+    UACPI_MAKE_STUB_FOR_REDUCED_HARDWARE(fn, UACPI_STATUS_OK)
+#else
+
+#define UACPI_STUB_IF_REDUCED_HARDWARE(fn) fn;
+#define UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(fn) fn;
+#define UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(fn) fn;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Set up early access to the table subsystem. What this means is:
+ * - uacpi_table_find() and similar API becomes usable before the call to
+ *   uacpi_initialize().
+ * - No kernel API besides logging and map/unmap will be invoked at this stage,
+ *   allowing for heap and scheduling to still be fully offline.
+ * - The provided 'temporary_buffer' will be used as a temporary storage for the
+ *   internal metadata about the tables (list, reference count, addresses,
+ *   sizes, etc).
+ * - The 'temporary_buffer' is replaced with a normal heap buffer allocated via
+ *   uacpi_kernel_alloc() after the call to uacpi_initialize() and can therefore
+ *   be reclaimed by the kernel.
+ *
+ * The approximate overhead per table is 56 bytes, so a buffer of 4096 bytes
+ * yields about 73 tables in terms of capacity. uACPI also has an internal
+ * static buffer for tables, "UACPI_STATIC_TABLE_ARRAY_LEN", which is configured
+ * as 16 descriptors in length by default.
+ *
+ * This function is used to initialize the barebones mode, see
+ * UACPI_BAREBONES_MODE in config.h for more information.
+ */
+uacpi_status uacpi_setup_early_table_access(
+    void *temporary_buffer, uacpi_size buffer_size
+);
+
+/*
+ * Bad table checksum should be considered a fatal error
+ * (table load is fully aborted in this case)
+ */
+#define UACPI_FLAG_BAD_CSUM_FATAL (1ull << 0)
+
+/*
+ * Unexpected table signature should be considered a fatal error
+ * (table load is fully aborted in this case)
+ */
+#define UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL (1ull << 1)
+
+/*
+ * Force uACPI to use RSDT even for later revisions
+ */
+#define UACPI_FLAG_BAD_XSDT (1ull << 2)
+
+/*
+ * If this is set, ACPI mode is not entered during the call to
+ * uacpi_initialize. The caller is expected to enter it later at their own
+ * discretion by using uacpi_enter_acpi_mode().
+ */
+#define UACPI_FLAG_NO_ACPI_MODE (1ull << 3)
+
+/*
+ * Don't create the \_OSI method when building the namespace.
+ * Only enable this if you're certain that having this method breaks your AML
+ * blob, a more atomic/granular interface management is available via osi.h
+ */
+#define UACPI_FLAG_NO_OSI (1ull << 4)
+
+/*
+ * Validate table checksums at installation time instead of first use.
+ * Note that this makes uACPI map the entire table at once, which not all
+ * hosts are able to handle at early init.
+ */
+#define UACPI_FLAG_PROACTIVE_TBL_CSUM (1ull << 5)
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Initializes the uACPI subsystem, iterates & records all relevant RSDT/XSDT
+ * tables. Enters ACPI mode.
+ *
+ * 'flags' is any combination of UACPI_FLAG_* above
+ */
+uacpi_status uacpi_initialize(uacpi_u64 flags);
+
+/*
+ * Parses & executes all of the DSDT/SSDT tables.
+ * Initializes the event subsystem.
+ */
+uacpi_status uacpi_namespace_load(void);
+
+/*
+ * Initializes all the necessary objects in the namespaces by calling
+ * _STA/_INI etc.
+ */
+uacpi_status uacpi_namespace_initialize(void);
+
+// Returns the current subsystem initialization level
+uacpi_init_level uacpi_get_current_init_level(void);
+
+/*
+ * Evaluate an object within the namespace and get back its value.
+ * Either root or path must be valid.
+ * A value of NULL for 'parent' implies uacpi_namespace_root() relative
+ * lookups, unless 'path' is already absolute.
+ */
+uacpi_status uacpi_eval(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * Same as uacpi_eval() but without a return value.
+ */
+uacpi_status uacpi_execute(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args
+);
+uacpi_status uacpi_execute_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path
+);
+
+/*
+ * Same as uacpi_eval, but the return value type is validated against
+ * the 'ret_mask'. UACPI_STATUS_TYPE_MISMATCH is returned on error.
+ */
+uacpi_status uacpi_eval_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object_type_bits ret_mask,
+    uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    uacpi_object_type_bits ret_mask, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_INTEGER_BIT.
+ */
+uacpi_status uacpi_eval_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_u64 *out_value
+);
+uacpi_status uacpi_eval_simple_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_u64 *out_value
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with
+ *     UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT
+ *
+ * Use uacpi_object_get_string_or_buffer to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_STRING_BIT.
+ *
+ * Use uacpi_object_get_string to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_BUFFER_BIT.
+ *
+ * Use uacpi_object_get_buffer to retrieve the resulting buffer data.
+ */
+uacpi_status uacpi_eval_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * A shorthand for uacpi_eval_typed with UACPI_OBJECT_PACKAGE_BIT.
+ *
+ * Use uacpi_object_get_package to retrieve the resulting object array.
+ */
+uacpi_status uacpi_eval_package(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+);
+uacpi_status uacpi_eval_simple_package(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+);
+
+/*
+ * Get the bitness of the currently loaded AML code according to the DSDT.
+ *
+ * Returns either 32 or 64.
+ */
+uacpi_status uacpi_get_aml_bitness(uacpi_u8 *out_bitness);
+
+/*
+ * Helpers for entering & leaving ACPI mode. Note that ACPI mode is entered
+ * automatically during the call to uacpi_initialize().
+ */
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_enter_acpi_mode(void)
+)
+UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_leave_acpi_mode(void)
+)
+
+/*
+ * Attempt to acquire the global lock for 'timeout' milliseconds.
+ * 0xFFFF implies infinite wait.
+ *
+ * On success, 'out_seq' is set to a unique sequence number for the current
+ * acquire transaction. This number is used for validation during release.
+ */
+uacpi_status uacpi_acquire_global_lock(uacpi_u16 timeout, uacpi_u32 *out_seq);
+uacpi_status uacpi_release_global_lock(uacpi_u32 seq);
+
+#endif // !UACPI_BAREBONES_MODE
+
+/*
+ * Reset the global uACPI state by freeing all internally allocated data
+ * structures & resetting any global variables. After this call, uACPI must be
+ * re-initialized from scratch to be used again.
+ *
+ * This is called by uACPI automatically if a fatal error occurs during a call
+ * to uacpi_initialize/uacpi_namespace_load etc. in order to prevent accidental
+ * use of partially uninitialized subsystems.
+ */
+void uacpi_state_reset(void);
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/include/uacpi/utilities.h

@@ -0,0 +1,188 @@
+#pragma once
+
+#include <uacpi/status.h>
+#include <uacpi/types.h>
+#include <uacpi/namespace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+/*
+ * Checks whether the device at 'node' matches any of the PNP ids provided in
+ * 'list' (terminated by a UACPI_NULL). This is done by first attempting to
+ * match the value returned from _HID and then the value(s) from _CID.
+ *
+ * Note that the presence of the device (_STA) is not verified here.
+ */
+uacpi_bool uacpi_device_matches_pnp_id(
+    uacpi_namespace_node *node,
+    const uacpi_char *const *list
+);
+
+/*
+ * Find all the devices in the namespace starting at 'parent' matching the
+ * specified 'hids' (terminated by a UACPI_NULL) against any value from _HID or
+ * _CID. Only devices reported as present via _STA are checked. Any matching
+ * devices are then passed to the 'cb'.
+ */
+uacpi_status uacpi_find_devices_at(
+    uacpi_namespace_node *parent,
+    const uacpi_char *const *hids,
+    uacpi_iteration_callback cb,
+    void *user
+);
+
+/*
+ * Same as uacpi_find_devices_at, except this starts at the root and only
+ * matches one hid.
+ */
+uacpi_status uacpi_find_devices(
+    const uacpi_char *hid,
+    uacpi_iteration_callback cb,
+    void *user
+);
+
+typedef enum uacpi_interrupt_model {
+    UACPI_INTERRUPT_MODEL_PIC = 0,
+    UACPI_INTERRUPT_MODEL_IOAPIC = 1,
+    UACPI_INTERRUPT_MODEL_IOSAPIC = 2,
+} uacpi_interrupt_model;
+
+uacpi_status uacpi_set_interrupt_model(uacpi_interrupt_model);
+
+typedef struct uacpi_pci_routing_table_entry {
+    uacpi_u32 address;
+    uacpi_u32 index;
+    uacpi_namespace_node *source;
+    uacpi_u8 pin;
+} uacpi_pci_routing_table_entry;
+
+typedef struct uacpi_pci_routing_table {
+    uacpi_size num_entries;
+    uacpi_pci_routing_table_entry entries[];
+} uacpi_pci_routing_table;
+void uacpi_free_pci_routing_table(uacpi_pci_routing_table*);
+
+uacpi_status uacpi_get_pci_routing_table(
+    uacpi_namespace_node *parent, uacpi_pci_routing_table **out_table
+);
+
+typedef struct uacpi_id_string {
+    // size of the string including the null byte
+    uacpi_u32 size;
+    uacpi_char *value;
+} uacpi_id_string;
+void uacpi_free_id_string(uacpi_id_string *id);
+
+/*
+ * Evaluate a device's _HID method and get its value.
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_hid(uacpi_namespace_node*, uacpi_id_string **out_id);
+
+typedef struct uacpi_pnp_id_list {
+    // number of 'ids' in the list
+    uacpi_u32 num_ids;
+
+    // size of the 'ids' list including the string lengths
+    uacpi_u32 size;
+
+    // list of PNP ids
+    uacpi_id_string ids[];
+} uacpi_pnp_id_list;
+void uacpi_free_pnp_id_list(uacpi_pnp_id_list *list);
+
+/*
+ * Evaluate a device's _CID method and get its value.
+ * The returned structure must be freed using uacpi_free_pnp_id_list.
+ */
+uacpi_status uacpi_eval_cid(uacpi_namespace_node*, uacpi_pnp_id_list **out_list);
+
+/*
+ * Evaluate a device's _STA method and get its value.
+ * If this method is not found, the value of 'flags' is set to all ones.
+ */
+uacpi_status uacpi_eval_sta(uacpi_namespace_node*, uacpi_u32 *flags);
+
+/*
+ * Evaluate a device's _ADR method and get its value.
+ */
+uacpi_status uacpi_eval_adr(uacpi_namespace_node*, uacpi_u64 *out);
+
+/*
+ * Evaluate a device's _CLS method and get its value.
+ * The format of returned string is BBSSPP where:
+ *     BB => Base Class (e.g. 01 => Mass Storage)
+ *     SS => Sub-Class (e.g. 06 => SATA)
+ *     PP => Programming Interface (e.g. 01 => AHCI)
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_cls(uacpi_namespace_node*, uacpi_id_string **out_id);
+
+/*
+ * Evaluate a device's _UID method and get its value.
+ * The returned struture must be freed using uacpi_free_id_string.
+ */
+uacpi_status uacpi_eval_uid(uacpi_namespace_node*, uacpi_id_string **out_uid);
+
+
+// uacpi_namespace_node_info->flags
+#define UACPI_NS_NODE_INFO_HAS_ADR (1 << 0)
+#define UACPI_NS_NODE_INFO_HAS_HID (1 << 1)
+#define UACPI_NS_NODE_INFO_HAS_UID (1 << 2)
+#define UACPI_NS_NODE_INFO_HAS_CID (1 << 3)
+#define UACPI_NS_NODE_INFO_HAS_CLS (1 << 4)
+#define UACPI_NS_NODE_INFO_HAS_SXD (1 << 5)
+#define UACPI_NS_NODE_INFO_HAS_SXW (1 << 6)
+
+typedef struct uacpi_namespace_node_info {
+    // Size of the entire structure
+    uacpi_u32 size;
+
+    // Object information
+    uacpi_object_name name;
+    uacpi_object_type type;
+    uacpi_u8 num_params;
+
+    // UACPI_NS_NODE_INFO_HAS_*
+    uacpi_u8 flags;
+
+    /*
+     * A mapping of [S1..S4] to the shallowest D state supported by the device
+     * in that S state.
+     */
+    uacpi_u8 sxd[4];
+
+    /*
+     * A mapping of [S0..S4] to the deepest D state supported by the device
+     * in that S state to be able to wake itself.
+     */
+    uacpi_u8 sxw[5];
+
+    uacpi_u64 adr;
+    uacpi_id_string hid;
+    uacpi_id_string uid;
+    uacpi_id_string cls;
+    uacpi_pnp_id_list cid;
+} uacpi_namespace_node_info;
+void uacpi_free_namespace_node_info(uacpi_namespace_node_info*);
+
+/*
+ * Retrieve information about a namespace node. This includes the attached
+ * object's type, name, number of parameters (if it's a method), the result of
+ * evaluating _ADR, _UID, _CLS, _HID, _CID, as well as _SxD and _SxW.
+ *
+ * The returned structure must be freed with uacpi_free_namespace_node_info.
+ */
+uacpi_status uacpi_get_namespace_node_info(
+    uacpi_namespace_node *node, uacpi_namespace_node_info **out_info
+);
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifdef __cplusplus
+}
+#endif

drivers/bus/acpi_new/uacpi/source/default_handlers.c

@@ -0,0 +1,336 @@
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/uacpi.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define PCI_ROOT_PNP_ID "PNP0A03"
+#define PCI_EXPRESS_ROOT_PNP_ID "PNP0A08"
+
+static uacpi_namespace_node *find_pci_root(uacpi_namespace_node *node)
+{
+    static const uacpi_char *pci_root_ids[] = {
+        PCI_ROOT_PNP_ID,
+        PCI_EXPRESS_ROOT_PNP_ID,
+        UACPI_NULL
+    };
+    uacpi_namespace_node *parent = node->parent;
+
+    while (parent != uacpi_namespace_root()) {
+        if (uacpi_device_matches_pnp_id(parent, pci_root_ids)) {
+            uacpi_trace(
+                "found a PCI root node %.4s controlling region %.4s\n",
+                parent->name.text, node->name.text
+            );
+            return parent;
+        }
+
+        parent = parent->parent;
+    }
+
+    uacpi_trace_region_error(
+        node, "unable to find PCI root controlling",
+        UACPI_STATUS_NOT_FOUND
+    );
+    return node;
+}
+
+static uacpi_status pci_region_attach(uacpi_region_attach_data *data)
+{
+    uacpi_namespace_node *node, *pci_root, *device;
+    uacpi_pci_address address = { 0 };
+    uacpi_u64 value;
+    uacpi_status ret;
+
+    node = data->region_node;
+    pci_root = find_pci_root(node);
+
+    /*
+     * Find the actual device object that is supposed to be controlling
+     * this operation region.
+     */
+    device = node;
+    while (device) {
+        uacpi_object_type type;
+
+        ret = uacpi_namespace_node_type(device, &type);
+        if (uacpi_unlikely_error(ret))
+            return ret;
+
+        if (type == UACPI_OBJECT_DEVICE)
+            break;
+
+        device = device->parent;
+    }
+
+    if (uacpi_unlikely(device == UACPI_NULL)) {
+        ret = UACPI_STATUS_NOT_FOUND;
+        uacpi_trace_region_error(
+            node, "unable to find device responsible for", ret
+        );
+        return ret;
+    }
+
+    ret = uacpi_eval_simple_integer(device, "_ADR", &value);
+    if (ret == UACPI_STATUS_OK) {
+        address.function = (value >> 0)  & 0xFF;
+        address.device   = (value >> 16) & 0xFF;
+    }
+
+    ret = uacpi_eval_simple_integer(pci_root, "_SEG", &value);
+    if (ret == UACPI_STATUS_OK)
+        address.segment = value;
+
+    ret = uacpi_eval_simple_integer(pci_root, "_BBN", &value);
+    if (ret == UACPI_STATUS_OK)
+        address.bus = value;
+
+    uacpi_trace(
+        "detected PCI device %.4s@%04X:%02X:%02X:%01X\n",
+        device->name.text, address.segment, address.bus,
+        address.device, address.function
+    );
+
+    return uacpi_kernel_pci_device_open(address, &data->out_region_context);
+}
+
+static uacpi_status pci_region_detach(uacpi_region_detach_data *data)
+{
+    uacpi_kernel_pci_device_close(data->region_context);
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status pci_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    uacpi_handle dev = data->region_context;
+    uacpi_u8 width;
+    uacpi_size offset;
+
+    offset = data->offset;
+    width = data->byte_width;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_pci_read(dev, offset, width, &data->value) :
+        uacpi_pci_write(dev, offset, width, data->value);
+}
+
+static uacpi_status handle_pci_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return pci_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return pci_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return pci_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+struct memory_region_ctx {
+    uacpi_phys_addr phys;
+    uacpi_u8 *virt;
+    uacpi_size size;
+};
+
+static uacpi_status memory_region_attach(uacpi_region_attach_data *data)
+{
+    struct memory_region_ctx *ctx;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    ctx = uacpi_kernel_alloc(sizeof(*ctx));
+    if (ctx == UACPI_NULL)
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    ctx->size = data->generic_info.length;
+
+    // FIXME: this really shouldn't try to map everything at once
+    ctx->phys = data->generic_info.base;
+    ctx->virt = uacpi_kernel_map(ctx->phys, ctx->size);
+
+    if (uacpi_unlikely(ctx->virt == UACPI_NULL)) {
+        ret = UACPI_STATUS_MAPPING_FAILED;
+        uacpi_trace_region_error(data->region_node, "unable to map", ret);
+        uacpi_free(ctx, sizeof(*ctx));
+        goto out;
+    }
+
+    data->out_region_context = ctx;
+out:
+    return ret;
+}
+
+static uacpi_status memory_region_detach(uacpi_region_detach_data *data)
+{
+    struct memory_region_ctx *ctx = data->region_context;
+
+    uacpi_kernel_unmap(ctx->virt, ctx->size);
+    uacpi_free(ctx, sizeof(*ctx));
+    return UACPI_STATUS_OK;
+}
+
+struct io_region_ctx {
+    uacpi_io_addr base;
+    uacpi_handle handle;
+};
+
+static uacpi_status io_region_attach(uacpi_region_attach_data *data)
+{
+    struct io_region_ctx *ctx;
+    uacpi_generic_region_info *info = &data->generic_info;
+    uacpi_status ret;
+
+    ctx = uacpi_kernel_alloc(sizeof(*ctx));
+    if (ctx == UACPI_NULL)
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    ctx->base = info->base;
+
+    ret = uacpi_kernel_io_map(ctx->base, info->length, &ctx->handle);
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_trace_region_error(
+            data->region_node, "unable to map an IO", ret
+        );
+        uacpi_free(ctx, sizeof(*ctx));
+        return ret;
+    }
+
+    data->out_region_context = ctx;
+    return ret;
+}
+
+static uacpi_status io_region_detach(uacpi_region_detach_data *data)
+{
+    struct io_region_ctx *ctx = data->region_context;
+
+    uacpi_kernel_io_unmap(ctx->handle);
+    uacpi_free(ctx, sizeof(*ctx));
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status memory_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    struct memory_region_ctx *ctx = data->region_context;
+    uacpi_size offset;
+
+    offset = data->address - ctx->phys;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_system_memory_read(ctx->virt, offset, data->byte_width, &data->value) :
+        uacpi_system_memory_write(ctx->virt, offset, data->byte_width, data->value);
+}
+
+static uacpi_status handle_memory_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return memory_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return memory_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return memory_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+static uacpi_status table_data_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    void *addr = UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)data->offset);
+
+    return op == UACPI_REGION_OP_READ ?
+       uacpi_system_memory_read(addr, 0, data->byte_width, &data->value) :
+       uacpi_system_memory_write(addr, 0, data->byte_width, data->value);
+}
+
+static uacpi_status handle_table_data_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+    case UACPI_REGION_OP_DETACH:
+        return UACPI_STATUS_OK;
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return table_data_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+static uacpi_status io_region_do_rw(
+    uacpi_region_op op, uacpi_region_rw_data *data
+)
+{
+    struct io_region_ctx *ctx = data->region_context;
+    uacpi_u8 width;
+    uacpi_size offset;
+
+    offset = data->offset - ctx->base;
+    width = data->byte_width;
+
+    return op == UACPI_REGION_OP_READ ?
+        uacpi_system_io_read(ctx->handle, offset, width, &data->value) :
+        uacpi_system_io_write(ctx->handle, offset, width, data->value);
+}
+
+static uacpi_status handle_io_region(uacpi_region_op op, uacpi_handle op_data)
+{
+    switch (op) {
+    case UACPI_REGION_OP_ATTACH:
+        return io_region_attach(op_data);
+    case UACPI_REGION_OP_DETACH:
+        return io_region_detach(op_data);
+    case UACPI_REGION_OP_READ:
+    case UACPI_REGION_OP_WRITE:
+        return io_region_do_rw(op, op_data);
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+}
+
+void uacpi_install_default_address_space_handlers(void)
+{
+    uacpi_namespace_node *root;
+
+    root = uacpi_namespace_root();
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_SYSTEM_MEMORY,
+        handle_memory_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_SYSTEM_IO,
+        handle_io_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_PCI_CONFIG,
+        handle_pci_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+
+    uacpi_install_address_space_handler_with_flags(
+        root, UACPI_ADDRESS_SPACE_TABLE_DATA,
+        handle_table_data_region, UACPI_NULL,
+        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
+    );
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/files.cmake

@@ -0,0 +1,21 @@
+uacpi_add_sources(
+    tables.c
+    types.c
+    uacpi.c
+    utilities.c
+    interpreter.c
+    opcodes.c
+    namespace.c
+    stdlib.c
+    shareable.c
+    opregion.c
+    default_handlers.c
+    io.c
+    notify.c
+    sleep.c
+    registers.c
+    resources.c
+    event.c
+    mutex.c
+    osi.c
+)

drivers/bus/acpi_new/uacpi/source/mutex.c

@@ -0,0 +1,396 @@
+#include <uacpi/platform/atomic.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/internal/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+
+#define GLOBAL_LOCK_PENDING (1 << 0)
+
+#define GLOBAL_LOCK_OWNED_BIT 1
+#define GLOBAL_LOCK_OWNED (1 << GLOBAL_LOCK_OWNED_BIT)
+
+#define GLOBAL_LOCK_MASK 0b11u
+
+static uacpi_bool try_acquire_global_lock_from_firmware(uacpi_u32 *lock)
+{
+    uacpi_u32 value, new_value;
+    uacpi_bool was_owned;
+
+    value = *(volatile uacpi_u32*)lock;
+    do {
+        was_owned = (value & GLOBAL_LOCK_OWNED) >> GLOBAL_LOCK_OWNED_BIT;
+
+        // Clear both owned & pending bits.
+        new_value = value & ~GLOBAL_LOCK_MASK;
+
+        // Set owned unconditionally
+        new_value |= GLOBAL_LOCK_OWNED;
+
+        // Set pending iff the lock was owned at the time of reading
+        if (was_owned)
+            new_value |= GLOBAL_LOCK_PENDING;
+    } while (!uacpi_atomic_cmpxchg32(lock, &value, new_value));
+
+    return !was_owned;
+}
+
+static uacpi_bool do_release_global_lock_to_firmware(uacpi_u32 *lock)
+{
+    uacpi_u32 value, new_value;
+
+    value = *(volatile uacpi_u32*)lock;
+    do {
+        new_value = value & ~GLOBAL_LOCK_MASK;
+    } while (!uacpi_atomic_cmpxchg32(lock, &value, new_value));
+
+    return value & GLOBAL_LOCK_PENDING;
+}
+
+static uacpi_status uacpi_acquire_global_lock_from_firmware(void)
+{
+    uacpi_cpu_flags flags;
+    uacpi_u16 spins = 0;
+    uacpi_bool success;
+
+    if (!g_uacpi_rt_ctx.has_global_lock)
+        return UACPI_STATUS_OK;
+
+    flags = uacpi_kernel_lock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+    for (;;) {
+        spins++;
+        uacpi_trace(
+            "trying to acquire the global lock from firmware... (attempt %u)\n",
+            spins
+        );
+
+        success = try_acquire_global_lock_from_firmware(
+            &g_uacpi_rt_ctx.facs->global_lock
+        );
+        if (success)
+            break;
+
+        if (uacpi_unlikely(spins == 0xFFFF))
+            break;
+
+        g_uacpi_rt_ctx.global_lock_pending = UACPI_TRUE;
+        uacpi_trace(
+            "global lock is owned by firmware, waiting for a release "
+            "notification...\n"
+        );
+        uacpi_kernel_unlock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock, flags);
+
+        uacpi_kernel_wait_for_event(g_uacpi_rt_ctx.global_lock_event, 0xFFFF);
+        flags = uacpi_kernel_lock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+    }
+
+    g_uacpi_rt_ctx.global_lock_pending = UACPI_FALSE;
+    uacpi_kernel_unlock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock, flags);
+
+    if (uacpi_unlikely(!success)) {
+        uacpi_error("unable to acquire global lock after %u attempts\n", spins);
+        return UACPI_STATUS_HARDWARE_TIMEOUT;
+    }
+
+    uacpi_trace("global lock successfully acquired after %u attempt%s\n",
+                spins, spins > 1 ? "s" : "");
+    return UACPI_STATUS_OK;
+}
+
+static void uacpi_release_global_lock_to_firmware(void)
+{
+    if (!g_uacpi_rt_ctx.has_global_lock)
+        return;
+
+    uacpi_trace("releasing the global lock to firmware...\n");
+    if (do_release_global_lock_to_firmware(&g_uacpi_rt_ctx.facs->global_lock)) {
+        uacpi_trace("notifying firmware of the global lock release since the "
+                    "pending bit was set\n");
+        uacpi_write_register_field(UACPI_REGISTER_FIELD_GBL_RLS, 1);
+    }
+}
+#endif
+
+UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(
+    uacpi_status uacpi_acquire_global_lock_from_firmware(void)
+)
+UACPI_STUB_IF_REDUCED_HARDWARE(
+    void uacpi_release_global_lock_to_firmware(void)
+)
+
+uacpi_status uacpi_acquire_native_mutex_with_timeout(
+    uacpi_handle mtx, uacpi_u16 timeout
+)
+{
+    uacpi_status ret;
+
+    if (uacpi_unlikely(mtx == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_kernel_acquire_mutex(mtx, timeout);
+    if (uacpi_likely_success(ret))
+        return ret;
+
+    if (uacpi_unlikely(ret != UACPI_STATUS_TIMEOUT || timeout == 0xFFFF)) {
+        uacpi_error(
+            "unexpected status %08X (%s) while acquiring %p (timeout=%04X)\n",
+            ret, uacpi_status_to_string(ret), mtx, timeout
+        );
+    }
+
+    return ret;
+}
+
+uacpi_status uacpi_acquire_global_lock(uacpi_u16 timeout, uacpi_u32 *out_seq)
+{
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(out_seq == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_acquire_native_mutex_with_timeout(
+        g_uacpi_rt_ctx.global_lock_mutex->handle, timeout
+    );
+    if (ret != UACPI_STATUS_OK)
+        return ret;
+
+    ret = uacpi_acquire_global_lock_from_firmware();
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_release_native_mutex(g_uacpi_rt_ctx.global_lock_mutex->handle);
+        return ret;
+    }
+
+    if (uacpi_unlikely(g_uacpi_rt_ctx.global_lock_seq_num == 0xFFFFFFFF))
+        g_uacpi_rt_ctx.global_lock_seq_num = 0;
+
+    *out_seq = g_uacpi_rt_ctx.global_lock_seq_num++;
+    g_uacpi_rt_ctx.global_lock_acquired = UACPI_TRUE;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_release_global_lock(uacpi_u32 seq)
+{
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(!g_uacpi_rt_ctx.global_lock_acquired ||
+                       seq != g_uacpi_rt_ctx.global_lock_seq_num))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    g_uacpi_rt_ctx.global_lock_acquired = UACPI_FALSE;
+    uacpi_release_global_lock_to_firmware();
+    uacpi_release_native_mutex(g_uacpi_rt_ctx.global_lock_mutex->handle);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_bool uacpi_this_thread_owns_aml_mutex(uacpi_mutex *mutex)
+{
+    uacpi_thread_id id;
+
+    id = UACPI_ATOMIC_LOAD_THREAD_ID(&mutex->owner);
+    return id == uacpi_kernel_get_thread_id();
+}
+
+uacpi_status uacpi_acquire_aml_mutex(uacpi_mutex *mutex, uacpi_u16 timeout)
+{
+    uacpi_thread_id this_id;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    this_id = uacpi_kernel_get_thread_id();
+    if (UACPI_ATOMIC_LOAD_THREAD_ID(&mutex->owner) == this_id) {
+        if (uacpi_unlikely(mutex->depth == 0xFFFF)) {
+            uacpi_warn(
+                "failing an attempt to acquire mutex @%p, too many recursive "
+                "acquires\n", mutex
+            );
+            return UACPI_STATUS_DENIED;
+        }
+
+        mutex->depth++;
+        return ret;
+    }
+
+    uacpi_namespace_write_unlock();
+    ret = uacpi_acquire_native_mutex_with_timeout(mutex->handle, timeout);
+    if (ret != UACPI_STATUS_OK)
+        goto out;
+
+    if (mutex->handle == g_uacpi_rt_ctx.global_lock_mutex->handle) {
+        ret = uacpi_acquire_global_lock_from_firmware();
+        if (uacpi_unlikely_error(ret)) {
+            uacpi_release_native_mutex(mutex->handle);
+            goto out;
+        }
+    }
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&mutex->owner, this_id);
+    mutex->depth = 1;
+
+out:
+    uacpi_namespace_write_lock();
+    return ret;
+}
+
+uacpi_status uacpi_release_aml_mutex(uacpi_mutex *mutex)
+{
+    if (mutex->depth-- > 1)
+        return UACPI_STATUS_OK;
+
+    if (mutex->handle == g_uacpi_rt_ctx.global_lock_mutex->handle)
+        uacpi_release_global_lock_to_firmware();
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&mutex->owner, UACPI_THREAD_ID_NONE);
+    uacpi_release_native_mutex(mutex->handle);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_init(struct uacpi_recursive_lock *lock)
+{
+    lock->mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    lock->owner = UACPI_THREAD_ID_NONE;
+    lock->depth = 0;
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_deinit(struct uacpi_recursive_lock *lock)
+{
+    if (uacpi_unlikely(lock->depth)) {
+        uacpi_warn(
+            "de-initializing active recursive lock %p with depth=%zu\n",
+            lock, lock->depth
+        );
+        lock->depth = 0;
+    }
+
+    lock->owner = UACPI_THREAD_ID_NONE;
+
+    if (lock->mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->mutex);
+        lock->mutex = UACPI_NULL;
+    }
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_recursive_lock_acquire(struct uacpi_recursive_lock *lock)
+{
+    uacpi_thread_id this_id;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    this_id = uacpi_kernel_get_thread_id();
+    if (UACPI_ATOMIC_LOAD_THREAD_ID(&lock->owner) == this_id) {
+        lock->depth++;
+        return ret;
+    }
+
+    ret = uacpi_acquire_native_mutex(lock->mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&lock->owner, this_id);
+    lock->depth = 1;
+    return ret;
+}
+
+uacpi_status uacpi_recursive_lock_release(struct uacpi_recursive_lock *lock)
+{
+    if (lock->depth-- > 1)
+        return UACPI_STATUS_OK;
+
+    UACPI_ATOMIC_STORE_THREAD_ID(&lock->owner, UACPI_THREAD_ID_NONE);
+    return uacpi_release_native_mutex(lock->mutex);
+}
+
+uacpi_status uacpi_rw_lock_init(struct uacpi_rw_lock *lock)
+{
+    lock->read_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->read_mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    lock->write_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(lock->write_mutex == UACPI_NULL)) {
+        uacpi_kernel_free_mutex(lock->read_mutex);
+        lock->read_mutex = UACPI_NULL;
+        return UACPI_STATUS_OUT_OF_MEMORY;
+    }
+
+    lock->num_readers = 0;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_rw_lock_deinit(struct uacpi_rw_lock *lock)
+{
+    if (uacpi_unlikely(lock->num_readers)) {
+        uacpi_warn("de-initializing rw_lock %p with %zu active readers\n",
+                   lock, lock->num_readers);
+        lock->num_readers = 0;
+    }
+
+    if (lock->read_mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->read_mutex);
+        lock->read_mutex = UACPI_NULL;
+    }
+    if (lock->write_mutex != UACPI_NULL) {
+        uacpi_kernel_free_mutex(lock->write_mutex);
+        lock->write_mutex = UACPI_NULL;
+    }
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_rw_lock_read(struct uacpi_rw_lock *lock)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex(lock->read_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (lock->num_readers++ == 0) {
+        ret = uacpi_acquire_native_mutex(lock->write_mutex);
+        if (uacpi_unlikely_error(ret))
+            lock->num_readers = 0;
+    }
+
+    uacpi_kernel_release_mutex(lock->read_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_rw_unlock_read(struct uacpi_rw_lock *lock)
+{
+    uacpi_status ret;
+
+    ret = uacpi_acquire_native_mutex(lock->read_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (lock->num_readers-- == 1)
+        uacpi_release_native_mutex(lock->write_mutex);
+
+    uacpi_kernel_release_mutex(lock->read_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_rw_lock_write(struct uacpi_rw_lock *lock)
+{
+    return uacpi_acquire_native_mutex(lock->write_mutex);
+}
+
+uacpi_status uacpi_rw_unlock_write(struct uacpi_rw_lock *lock)
+{
+    return uacpi_release_native_mutex(lock->write_mutex);
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/notify.c

@@ -0,0 +1,255 @@
+#include <uacpi/internal/notify.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/kernel_api.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+static uacpi_handle notify_mutex;
+
+uacpi_status uacpi_initialize_notify(void)
+{
+    notify_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(notify_mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    return UACPI_STATUS_OK;
+}
+
+void uacpi_deinitialize_notify(void)
+{
+    if (notify_mutex != UACPI_NULL)
+        uacpi_kernel_free_mutex(notify_mutex);
+
+    notify_mutex = UACPI_NULL;
+}
+
+struct notification_ctx {
+    uacpi_namespace_node *node;
+    uacpi_u64 value;
+    uacpi_object *node_object;
+};
+
+static void free_notification_ctx(struct notification_ctx *ctx)
+{
+    uacpi_namespace_node_release_object(ctx->node_object);
+    uacpi_namespace_node_unref(ctx->node);
+    uacpi_free(ctx, sizeof(*ctx));
+}
+
+static void do_notify(uacpi_handle opaque)
+{
+    struct notification_ctx *ctx = opaque;
+    uacpi_device_notify_handler *handler;
+    uacpi_bool did_notify_root = UACPI_FALSE;
+
+    handler = ctx->node_object->handlers->notify_head;
+
+    for (;;) {
+        if (handler == UACPI_NULL) {
+            if (did_notify_root) {
+                free_notification_ctx(ctx);
+                return;
+            }
+
+            handler = g_uacpi_rt_ctx.root_object->handlers->notify_head;
+            did_notify_root = UACPI_TRUE;
+            continue;
+        }
+
+        handler->callback(handler->user_context, ctx->node, ctx->value);
+        handler = handler->next;
+    }
+}
+
+uacpi_status uacpi_notify_all(uacpi_namespace_node *node, uacpi_u64 value)
+{
+    uacpi_status ret;
+    struct notification_ctx *ctx;
+    uacpi_object *node_object;
+
+    node_object = uacpi_namespace_node_get_object_typed(
+        node, UACPI_OBJECT_DEVICE_BIT | UACPI_OBJECT_THERMAL_ZONE_BIT |
+              UACPI_OBJECT_PROCESSOR_BIT
+    );
+    if (uacpi_unlikely(node_object == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_acquire_native_mutex(notify_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (node_object->handlers->notify_head == UACPI_NULL &&
+        g_uacpi_rt_ctx.root_object->handlers->notify_head == UACPI_NULL) {
+        ret = UACPI_STATUS_NO_HANDLER;
+        goto out;
+    }
+
+    ctx = uacpi_kernel_alloc(sizeof(*ctx));
+    if (uacpi_unlikely(ctx == UACPI_NULL)) {
+        ret = UACPI_STATUS_OUT_OF_MEMORY;
+        goto out;
+    }
+
+    ctx->node = node;
+    // In case this node goes out of scope
+    uacpi_shareable_ref(node);
+
+    ctx->value = value;
+    ctx->node_object = uacpi_namespace_node_get_object(node);
+    uacpi_object_ref(ctx->node_object);
+
+    ret = uacpi_kernel_schedule_work(UACPI_WORK_NOTIFICATION, do_notify, ctx);
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_warn("unable to schedule notification work: %s\n",
+                   uacpi_status_to_string(ret));
+        free_notification_ctx(ctx);
+    }
+
+out:
+    uacpi_release_native_mutex(notify_mutex);
+    return ret;
+}
+
+static uacpi_device_notify_handler *handler_container(
+    uacpi_handlers *handlers, uacpi_notify_handler target_handler
+)
+{
+    uacpi_device_notify_handler *handler = handlers->notify_head;
+
+    while (handler) {
+        if (handler->callback == target_handler)
+            return handler;
+
+        handler = handler->next;
+    }
+
+    return UACPI_NULL;
+}
+
+uacpi_status uacpi_install_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler,
+    uacpi_handle handler_context
+)
+{
+    uacpi_status ret;
+    uacpi_object *obj;
+    uacpi_handlers *handlers;
+    uacpi_device_notify_handler *new_handler;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (node == uacpi_namespace_root()) {
+        obj = g_uacpi_rt_ctx.root_object;
+    } else {
+        ret = uacpi_namespace_node_acquire_object_typed(
+            node, UACPI_OBJECT_DEVICE_BIT | UACPI_OBJECT_THERMAL_ZONE_BIT |
+                  UACPI_OBJECT_PROCESSOR_BIT, &obj
+        );
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    }
+
+    ret = uacpi_acquire_native_mutex(notify_mutex);
+    if (uacpi_unlikely_error(ret))
+        goto out_no_mutex;
+
+    uacpi_kernel_wait_for_work_completion();
+
+    handlers = obj->handlers;
+
+    if (handler_container(handlers, handler) != UACPI_NULL) {
+        ret = UACPI_STATUS_ALREADY_EXISTS;
+        goto out;
+    }
+
+    new_handler = uacpi_kernel_alloc_zeroed(sizeof(*new_handler));
+    if (uacpi_unlikely(new_handler == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    new_handler->callback = handler;
+    new_handler->user_context = handler_context;
+    new_handler->next = handlers->notify_head;
+
+    handlers->notify_head = new_handler;
+
+out:
+    uacpi_release_native_mutex(notify_mutex);
+out_no_mutex:
+    if (node != uacpi_namespace_root())
+        uacpi_object_unref(obj);
+
+    return ret;
+}
+
+uacpi_status uacpi_uninstall_notify_handler(
+    uacpi_namespace_node *node, uacpi_notify_handler handler
+)
+{
+    uacpi_status ret;
+    uacpi_object *obj;
+    uacpi_handlers *handlers;
+    uacpi_device_notify_handler *prev_handler, *containing = UACPI_NULL;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (node == uacpi_namespace_root()) {
+        obj = g_uacpi_rt_ctx.root_object;
+    } else {
+        ret = uacpi_namespace_node_acquire_object_typed(
+            node, UACPI_OBJECT_DEVICE_BIT | UACPI_OBJECT_THERMAL_ZONE_BIT |
+                  UACPI_OBJECT_PROCESSOR_BIT, &obj
+        );
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    }
+
+    ret = uacpi_acquire_native_mutex(notify_mutex);
+    if (uacpi_unlikely_error(ret))
+        goto out_no_mutex;
+
+    uacpi_kernel_wait_for_work_completion();
+
+    handlers = obj->handlers;
+
+    containing = handler_container(handlers, handler);
+    if (containing == UACPI_NULL) {
+        ret = UACPI_STATUS_NOT_FOUND;
+        goto out;
+    }
+
+    prev_handler = handlers->notify_head;
+
+    // Are we the last linked handler?
+    if (prev_handler == containing) {
+        handlers->notify_head = containing->next;
+        goto out;
+    }
+
+    // Nope, we're somewhere in the middle. Do a search.
+    while (prev_handler) {
+        if (prev_handler->next == containing) {
+            prev_handler->next = containing->next;
+            goto out;
+        }
+
+        prev_handler = prev_handler->next;
+    }
+
+out:
+    uacpi_release_native_mutex(notify_mutex);
+out_no_mutex:
+    if (node != uacpi_namespace_root())
+        uacpi_object_unref(obj);
+
+    if (uacpi_likely_success(ret))
+        uacpi_free(containing, sizeof(*containing));
+
+    return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/opcodes.c

@@ -0,0 +1,272 @@
+#include <uacpi/internal/opcodes.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define UACPI_OP(opname, opcode, ...) \
+    { #opname, .decode_ops = __VA_ARGS__, .code = opcode },
+
+#define UACPI_OUT_OF_LINE_OP(opname, opcode, out_of_line_buf, props) \
+    {                                                                \
+      .name = #opname,                                               \
+      .indirect_decode_ops = out_of_line_buf,                        \
+      .properties = props,                                           \
+      .code = opcode,                                                \
+    },
+
+static const struct uacpi_op_spec opcode_table[0x100] = {
+    UACPI_ENUMERATE_OPCODES
+};
+
+static const struct uacpi_op_spec ext_opcode_table[] = {
+    UACPI_ENUMERATE_EXT_OPCODES
+};
+
+#define _(op) (op & 0x00FF)
+
+static const uacpi_u8 ext_op_to_idx[0x100] = {
+    [_(UACPI_AML_OP_MutexOp)]       = 1,  [_(UACPI_AML_OP_EventOp)]       = 2,
+    [_(UACPI_AML_OP_CondRefOfOp)]   = 3,  [_(UACPI_AML_OP_CreateFieldOp)] = 4,
+    [_(UACPI_AML_OP_LoadTableOp)]   = 5,  [_(UACPI_AML_OP_LoadOp)]        = 6,
+    [_(UACPI_AML_OP_StallOp)]       = 7,  [_(UACPI_AML_OP_SleepOp)]       = 8,
+    [_(UACPI_AML_OP_AcquireOp)]     = 9,  [_(UACPI_AML_OP_SignalOp)]      = 10,
+    [_(UACPI_AML_OP_WaitOp)]        = 11, [_(UACPI_AML_OP_ResetOp)]       = 12,
+    [_(UACPI_AML_OP_ReleaseOp)]     = 13, [_(UACPI_AML_OP_FromBCDOp)]     = 14,
+    [_(UACPI_AML_OP_ToBCDOp)]       = 15, [_(UACPI_AML_OP_UnloadOp)]      = 16,
+    [_(UACPI_AML_OP_RevisionOp)]    = 17, [_(UACPI_AML_OP_DebugOp)]       = 18,
+    [_(UACPI_AML_OP_FatalOp)]       = 19, [_(UACPI_AML_OP_TimerOp)]       = 20,
+    [_(UACPI_AML_OP_OpRegionOp)]    = 21, [_(UACPI_AML_OP_FieldOp)]       = 22,
+    [_(UACPI_AML_OP_DeviceOp)]      = 23, [_(UACPI_AML_OP_ProcessorOp)]   = 24,
+    [_(UACPI_AML_OP_PowerResOp)]    = 25, [_(UACPI_AML_OP_ThermalZoneOp)] = 26,
+    [_(UACPI_AML_OP_IndexFieldOp)]  = 27, [_(UACPI_AML_OP_BankFieldOp)]   = 28,
+    [_(UACPI_AML_OP_DataRegionOp)]  = 29,
+};
+
+const struct uacpi_op_spec *uacpi_get_op_spec(uacpi_aml_op op)
+{
+    if (op > 0xFF)
+        return &ext_opcode_table[ext_op_to_idx[_(op)]];
+
+    return &opcode_table[op];
+}
+
+#define PARSE_FIELD_ELEMENTS(parse_loop_pc)                            \
+    /* Parse every field element found inside */                       \
+    UACPI_PARSE_OP_IF_HAS_DATA, 44,                                    \
+        /* Look at the first byte */                                   \
+        UACPI_PARSE_OP_LOAD_IMM, 1,                                    \
+                                                                       \
+        /* ReservedField := 0x00 PkgLength */                          \
+        UACPI_PARSE_OP_IF_LAST_EQUALS, 0x00, 3,                        \
+            UACPI_PARSE_OP_PKGLEN,                                     \
+            UACPI_PARSE_OP_JMP, parse_loop_pc,                         \
+                                                                       \
+        /* AccessField := 0x01 AccessType AccessAttrib */              \
+        UACPI_PARSE_OP_IF_LAST_EQUALS, 0x01, 6,                        \
+            UACPI_PARSE_OP_LOAD_IMM, 1,                                \
+            UACPI_PARSE_OP_LOAD_IMM, 1,                                \
+            UACPI_PARSE_OP_JMP, parse_loop_pc,                         \
+                                                                       \
+        /* ConnectField := <0x02 NameString> | <0x02 BufferData> */    \
+        UACPI_PARSE_OP_IF_LAST_EQUALS, 0x02, 5,                        \
+            UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL,                   \
+            UACPI_PARSE_OP_TYPECHECK, UACPI_OBJECT_BUFFER,             \
+            UACPI_PARSE_OP_JMP, parse_loop_pc,                         \
+                                                                       \
+        /* ExtendedAccessField := 0x03 AccessType ExtendedAccessAttrib \
+         *                                        AccessLength */      \
+        UACPI_PARSE_OP_IF_LAST_EQUALS, 0x03, 8,                        \
+            UACPI_PARSE_OP_LOAD_IMM, 1,                                \
+            UACPI_PARSE_OP_LOAD_IMM, 1,                                \
+            UACPI_PARSE_OP_LOAD_IMM, 1,                                \
+            UACPI_PARSE_OP_JMP, parse_loop_pc,                         \
+                                                                       \
+        /* NamedField := NameSeg PkgLength */                          \
+                                                                       \
+        /*                                                             \
+         * Discard the immediate, as it's the first byte of the        \
+         * nameseg. We don't need it.                                  \
+         */                                                            \
+        UACPI_PARSE_OP_ITEM_POP,                                       \
+        UACPI_PARSE_OP_AML_PC_DECREMENT,                               \
+        UACPI_PARSE_OP_CREATE_NAMESTRING,                              \
+        UACPI_PARSE_OP_PKGLEN,                                         \
+        UACPI_PARSE_OP_OBJECT_ALLOC_TYPED, UACPI_OBJECT_FIELD_UNIT,    \
+        UACPI_PARSE_OP_JMP, parse_loop_pc,                             \
+                                                                       \
+    UACPI_PARSE_OP_INVOKE_HANDLER,                                     \
+    UACPI_PARSE_OP_END
+
+uacpi_u8 uacpi_field_op_decode_ops[] = {
+    UACPI_PARSE_OP_TRACKED_PKGLEN,
+    UACPI_PARSE_OP_EXISTING_NAMESTRING,
+    UACPI_PARSE_OP_LOAD_IMM, 1,
+    PARSE_FIELD_ELEMENTS(4),
+};
+
+uacpi_u8 uacpi_bank_field_op_decode_ops[] = {
+    UACPI_PARSE_OP_TRACKED_PKGLEN,
+    UACPI_PARSE_OP_EXISTING_NAMESTRING,
+    UACPI_PARSE_OP_EXISTING_NAMESTRING,
+    UACPI_PARSE_OP_OPERAND,
+    UACPI_PARSE_OP_LOAD_IMM, 1,
+    PARSE_FIELD_ELEMENTS(6),
+};
+
+uacpi_u8 uacpi_index_field_op_decode_ops[] = {
+    UACPI_PARSE_OP_TRACKED_PKGLEN,
+    UACPI_PARSE_OP_EXISTING_NAMESTRING,
+    UACPI_PARSE_OP_EXISTING_NAMESTRING,
+    UACPI_PARSE_OP_LOAD_IMM, 1,
+    PARSE_FIELD_ELEMENTS(5),
+};
+
+uacpi_u8 uacpi_load_op_decode_ops[] = {
+    // Storage for the scope pointer, this is left as 0 in case of errors
+    UACPI_PARSE_OP_LOAD_ZERO_IMM,
+    UACPI_PARSE_OP_OBJECT_ALLOC_TYPED, UACPI_OBJECT_METHOD,
+    UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL,
+    UACPI_PARSE_OP_TARGET,
+
+    /*
+     * Invoke the handler here to initialize the table. If this fails, it's
+     * expected to keep the item 0 as NULL, which is checked below to return
+     * false to the caller of Load.
+     */
+    UACPI_PARSE_OP_INVOKE_HANDLER,
+    UACPI_PARSE_OP_IF_NULL, 0, 3,
+        UACPI_PARSE_OP_LOAD_FALSE_OBJECT,
+        UACPI_PARSE_OP_JMP, 15,
+
+    UACPI_PARSE_OP_LOAD_TRUE_OBJECT,
+    UACPI_PARSE_OP_DISPATCH_TABLE_LOAD,
+
+    /*
+     * Invoke the handler a second time to initialize any AML GPE handlers that
+     * might've been loaded from this table.
+     */
+    UACPI_PARSE_OP_INVOKE_HANDLER,
+    UACPI_PARSE_OP_STORE_TO_TARGET, 3,
+    UACPI_PARSE_OP_OBJECT_TRANSFER_TO_PREV,
+    UACPI_PARSE_OP_END,
+};
+
+uacpi_u8 uacpi_load_table_op_decode_ops[] = {
+    // Storage for the scope pointer, this is left as 0 in case of errors
+    UACPI_PARSE_OP_LOAD_ZERO_IMM,
+    UACPI_PARSE_OP_OBJECT_ALLOC_TYPED, UACPI_OBJECT_METHOD,
+    // Index of the table we are going to be loaded to unref it later
+    UACPI_PARSE_OP_LOAD_ZERO_IMM,
+    // Storage for the target pointer, this is left as 0 if none was requested
+    UACPI_PARSE_OP_LOAD_ZERO_IMM,
+
+    UACPI_PARSE_OP_LOAD_INLINE_IMM, 1, 5,
+    UACPI_PARSE_OP_IF_NOT_NULL, 4, 5,
+        UACPI_PARSE_OP_STRING,
+        UACPI_PARSE_OP_IMM_DECREMENT, 4,
+        UACPI_PARSE_OP_JMP, 8,
+    UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL,
+
+    /*
+     * Invoke the handler here to initialize the table. If this fails, it's
+     * expected to keep the item 0 as NULL, which is checked below to return
+     * false to the caller of Load.
+     */
+    UACPI_PARSE_OP_INVOKE_HANDLER,
+    UACPI_PARSE_OP_IF_NULL, 0, 3,
+        UACPI_PARSE_OP_LOAD_FALSE_OBJECT,
+        UACPI_PARSE_OP_OBJECT_TRANSFER_TO_PREV,
+        UACPI_PARSE_OP_END,
+
+    UACPI_PARSE_OP_LOAD_TRUE_OBJECT,
+    UACPI_PARSE_OP_DISPATCH_TABLE_LOAD,
+
+    /*
+     * Invoke the handler a second time to block the store to target in case
+     * the load above failed, as well as do any AML GPE handler initialization.
+     */
+    UACPI_PARSE_OP_INVOKE_HANDLER,
+
+    // If we were given a target to store to, do the store
+    UACPI_PARSE_OP_IF_NOT_NULL, 3, 3,
+        UACPI_PARSE_OP_STORE_TO_TARGET_INDIRECT, 3, 10,
+
+    UACPI_PARSE_OP_OBJECT_TRANSFER_TO_PREV,
+    UACPI_PARSE_OP_END,
+};
+
+#define POP(x) UACPI_PARSE_OP_##x
+
+static
+const uacpi_char *const pop_names[UACPI_PARSE_OP_MAX + 1] = {
+    [POP(END)] = "<END-OF-OP>",
+    [POP(SKIP_WITH_WARN_IF_NULL)] = "SKIP_WITH_WARN_IF_NULL",
+    [POP(EMIT_SKIP_WARN)] = "EMIT_SKIP_WARN",
+    [POP(SIMPLE_NAME)] = "SIMPLE_NAME",
+    [POP(SUPERNAME)] = "SUPERNAME",
+    [POP(SUPERNAME_OR_UNRESOLVED)] = "SUPERNAME_OR_UNRESOLVED",
+    [POP(TERM_ARG)] = "TERM_ARG",
+    [POP(TERM_ARG_UNWRAP_INTERNAL)] = "TERM_ARG_UNWRAP_INTERNAL",
+    [POP(TERM_ARG_OR_NAMED_OBJECT)] = "TERM_ARG_OR_NAMED_OBJECT",
+    [POP(TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED)] = "TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED",
+    [POP(OPERAND)] = "OPERAND",
+    [POP(STRING)] = "STRING",
+    [POP(COMPUTATIONAL_DATA)] = "COMPUTATIONAL_DATA",
+    [POP(TARGET)] = "TARGET",
+    [POP(PKGLEN)] = "PKGLEN",
+    [POP(TRACKED_PKGLEN)] = "TRACKED_PKGLEN",
+    [POP(CREATE_NAMESTRING)] = "CREATE_NAMESTRING",
+    [POP(CREATE_NAMESTRING_OR_NULL_IF_LOAD)] = "CREATE_NAMESTRING_OR_NULL_IF_LOAD",
+    [POP(EXISTING_NAMESTRING)] = "EXISTING_NAMESTRING",
+    [POP(EXISTING_NAMESTRING_OR_NULL)] = "EXISTING_NAMESTRING_OR_NULL",
+    [POP(EXISTING_NAMESTRING_OR_NULL_IF_LOAD)] = "EXISTING_NAMESTRING_OR_NULL_IF_LOAD",
+    [POP(INVOKE_HANDLER)] = "INVOKE_HANDLER",
+    [POP(OBJECT_ALLOC)] = "OBJECT_ALLOC",
+    [POP(EMPTY_OBJECT_ALLOC)] = "EMPTY_OBJECT_ALLOC",
+    [POP(OBJECT_CONVERT_TO_SHALLOW_COPY)] = "OBJECT_CONVERT_TO_SHALLOW_COPY",
+    [POP(OBJECT_CONVERT_TO_DEEP_COPY)] = "OBJECT_CONVERT_TO_DEEP_COPY",
+    [POP(OBJECT_ALLOC_TYPED)] = "OBJECT_ALLOC_TYPED",
+    [POP(RECORD_AML_PC)] = "RECORD_AML_PC",
+    [POP(LOAD_INLINE_IMM_AS_OBJECT)] = "LOAD_INLINE_IMM_AS_OBJECT",
+    [POP(LOAD_INLINE_IMM)] = "LOAD_INLINE_IMM",
+    [POP(LOAD_ZERO_IMM)] = "LOAD_ZERO_IMM",
+    [POP(LOAD_IMM)] = "LOAD_IMM",
+    [POP(LOAD_IMM_AS_OBJECT)] = "LOAD_IMM_AS_OBJECT",
+    [POP(LOAD_FALSE_OBJECT)] = "LOAD_FALSE_OBJECT",
+    [POP(LOAD_TRUE_OBJECT)] = "LOAD_TRUE_OBJECT",
+    [POP(TRUNCATE_NUMBER)] = "TRUNCATE_NUMBER",
+    [POP(TYPECHECK)] = "TYPECHECK",
+    [POP(INSTALL_NAMESPACE_NODE)] = "INSTALL_NAMESPACE_NODE",
+    [POP(OBJECT_TRANSFER_TO_PREV)] = "OBJECT_TRANSFER_TO_PREV",
+    [POP(OBJECT_COPY_TO_PREV)] = "OBJECT_COPY_TO_PREV",
+    [POP(STORE_TO_TARGET)] = "STORE_TO_TARGET",
+    [POP(STORE_TO_TARGET_INDIRECT)] = "STORE_TO_TARGET_INDIRECT",
+    [POP(UNREACHABLE)] = "UNREACHABLE",
+    [POP(BAD_OPCODE)] = "BAD_OPCODE",
+    [POP(AML_PC_DECREMENT)] = "AML_PC_DECREMENT",
+    [POP(IMM_DECREMENT)] = "IMM_DECREMENT",
+    [POP(ITEM_POP)] = "ITEM_POP",
+    [POP(DISPATCH_METHOD_CALL)] = "DISPATCH_METHOD_CALL",
+    [POP(DISPATCH_TABLE_LOAD)] = "DISPATCH_TABLE_LOAD",
+    [POP(CONVERT_NAMESTRING)] = "CONVERT_NAMESTRING",
+    [POP(IF_HAS_DATA)] = "IF_HAS_DATA",
+    [POP(IF_NULL)] = "IF_NULL",
+    [POP(IF_LAST_NULL)] = "IF_LAST_NULL",
+    [POP(IF_NOT_NULL)] = "IF_NOT_NULL",
+    [POP(IF_LAST_NOT_NULL)] = "IF_NOT_NULL",
+    [POP(IF_LAST_EQUALS)] = "IF_LAST_EQUALS",
+    [POP(IF_LAST_FALSE)] = "IF_LAST_FALSE",
+    [POP(IF_LAST_TRUE)] = "IF_LAST_TRUE",
+    [POP(SWITCH_TO_NEXT_IF_EQUALS)] = "SWITCH_TO_NEXT_IF_EQUALS",
+    [POP(IF_SWITCHED_FROM)] = "IF_SWITCHED_FROM",
+    [POP(JMP)] = "JMP",
+};
+
+const uacpi_char *uacpi_parse_op_to_string(enum uacpi_parse_op op)
+{
+    if (uacpi_unlikely(op > UACPI_PARSE_OP_MAX))
+        return "<INVALID-OP>";
+
+    return pop_names[op];
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/osi.c

@@ -0,0 +1,388 @@
+#include <uacpi/platform/atomic.h>
+#include <uacpi/internal/osi.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/kernel_api.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+struct registered_interface {
+    const uacpi_char *name;
+    uacpi_u8 weight;
+    uacpi_u8 kind;
+
+    // Only applicable for predefined host interfaces
+    uacpi_u8 host_type;
+
+    // Only applicable for predefined interfaces
+    uacpi_u8 disabled : 1;
+    uacpi_u8 dynamic : 1;
+
+    struct registered_interface *next;
+};
+
+static uacpi_handle interface_mutex;
+static struct registered_interface *registered_interfaces;
+static uacpi_interface_handler interface_handler;
+static uacpi_u32 latest_queried_interface;
+
+#define WINDOWS(string, interface)                            \
+    {                                                         \
+        .name = "Windows "string,                             \
+        .weight = UACPI_VENDOR_INTERFACE_WINDOWS_##interface, \
+        .kind = UACPI_INTERFACE_KIND_VENDOR,                  \
+        .host_type = 0,                                       \
+        .disabled = 0,                                        \
+        .dynamic = 0,                                         \
+        .next = UACPI_NULL                                    \
+    }
+
+#define HOST_FEATURE(string, type)                \
+    {                                             \
+        .name = string,                           \
+        .weight = 0,                              \
+        .kind = UACPI_INTERFACE_KIND_FEATURE,     \
+        .host_type = UACPI_HOST_INTERFACE_##type, \
+        .disabled = 1,                            \
+        .dynamic = 0,                             \
+        .next = UACPI_NULL,                       \
+    }
+
+static struct registered_interface predefined_interfaces[] = {
+    // Vendor strings
+    WINDOWS("2000", 2000),
+    WINDOWS("2001", XP),
+    WINDOWS("2001 SP1", XP_SP1),
+    WINDOWS("2001.1", SERVER_2003),
+    WINDOWS("2001 SP2", XP_SP2),
+    WINDOWS("2001.1 SP1", SERVER_2003_SP1),
+    WINDOWS("2006", VISTA),
+    WINDOWS("2006.1", SERVER_2008),
+    WINDOWS("2006 SP1", VISTA_SP1),
+    WINDOWS("2006 SP2", VISTA_SP2),
+    WINDOWS("2009", 7),
+    WINDOWS("2012", 8),
+    WINDOWS("2013", 8_1),
+    WINDOWS("2015", 10),
+    WINDOWS("2016", 10_RS1),
+    WINDOWS("2017", 10_RS2),
+    WINDOWS("2017.2", 10_RS3),
+    WINDOWS("2018", 10_RS4),
+    WINDOWS("2018.2", 10_RS5),
+    WINDOWS("2019", 10_19H1),
+    WINDOWS("2020", 10_20H1),
+    WINDOWS("2021", 11),
+    WINDOWS("2022", 11_22H2),
+
+    // Feature strings
+    HOST_FEATURE("Module Device", MODULE_DEVICE),
+    HOST_FEATURE("Processor Device", PROCESSOR_DEVICE),
+    HOST_FEATURE("3.0 Thermal Model", 3_0_THERMAL_MODEL),
+    HOST_FEATURE("3.0 _SCP Extensions", 3_0_SCP_EXTENSIONS),
+    HOST_FEATURE("Processor Aggregator Device", PROCESSOR_AGGREGATOR_DEVICE),
+
+    // Interpreter features
+    { .name = "Extended Address Space Descriptor" },
+};
+
+uacpi_status uacpi_initialize_interfaces(void)
+{
+    uacpi_size i;
+
+    registered_interfaces = &predefined_interfaces[0];
+
+    interface_mutex = uacpi_kernel_create_mutex();
+    if (uacpi_unlikely(interface_mutex == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    for (i = 0; i < (UACPI_ARRAY_SIZE(predefined_interfaces) - 1); ++i)
+        predefined_interfaces[i].next = &predefined_interfaces[i + 1];
+
+    return UACPI_STATUS_OK;
+}
+
+void uacpi_deinitialize_interfaces(void)
+{
+    struct registered_interface *iface, *next_iface = registered_interfaces;
+
+    while (next_iface) {
+        iface = next_iface;
+        next_iface = iface->next;
+
+        iface->next = UACPI_NULL;
+
+        if (iface->dynamic) {
+            uacpi_free_dynamic_string(iface->name);
+            uacpi_free(iface, sizeof(*iface));
+            continue;
+        }
+
+        // Only features are disabled by default
+        iface->disabled = iface->kind == UACPI_INTERFACE_KIND_FEATURE ?
+                UACPI_TRUE : UACPI_FALSE;
+    }
+
+    if (interface_mutex)
+        uacpi_kernel_free_mutex(interface_mutex);
+
+    interface_mutex = UACPI_NULL;
+    interface_handler = UACPI_NULL;
+    latest_queried_interface = 0;
+    registered_interfaces = UACPI_NULL;
+}
+
+uacpi_vendor_interface uacpi_latest_queried_vendor_interface(void)
+{
+    return uacpi_atomic_load32(&latest_queried_interface);
+}
+
+static struct registered_interface *find_interface_unlocked(
+    const uacpi_char *name
+)
+{
+    struct registered_interface *interface = registered_interfaces;
+
+    while (interface) {
+        if (uacpi_strcmp(interface->name, name) == 0)
+            return interface;
+
+        interface = interface->next;
+    }
+
+    return UACPI_NULL;
+}
+
+static struct registered_interface *find_host_interface_unlocked(
+    uacpi_host_interface type
+)
+{
+    struct registered_interface *interface = registered_interfaces;
+
+    while (interface) {
+        if (interface->host_type == type)
+            return interface;
+
+        interface = interface->next;
+    }
+
+    return UACPI_NULL;
+}
+
+uacpi_status uacpi_install_interface(
+    const uacpi_char *name, uacpi_interface_kind kind
+)
+{
+    struct registered_interface *interface;
+    uacpi_status ret;
+    uacpi_char *name_copy;
+    uacpi_size name_size;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    interface = find_interface_unlocked(name);
+    if (interface != UACPI_NULL) {
+        if (interface->disabled)
+            interface->disabled = UACPI_FALSE;
+
+        ret = UACPI_STATUS_ALREADY_EXISTS;
+        goto out;
+    }
+
+    interface = uacpi_kernel_alloc(sizeof(*interface));
+    if (uacpi_unlikely(interface == UACPI_NULL)) {
+        ret = UACPI_STATUS_OUT_OF_MEMORY;
+        goto out;
+    }
+
+    name_size = uacpi_strlen(name) + 1;
+    name_copy = uacpi_kernel_alloc(name_size);
+    if (uacpi_unlikely(name_copy == UACPI_NULL)) {
+        uacpi_free(interface, sizeof(*interface));
+        ret = UACPI_STATUS_OUT_OF_MEMORY;
+        goto out;
+    }
+
+    uacpi_memcpy(name_copy, name, name_size);
+    interface->name = name_copy;
+    interface->weight = 0;
+    interface->kind = kind;
+    interface->host_type = 0;
+    interface->disabled = 0;
+    interface->dynamic = 1;
+    interface->next = registered_interfaces;
+    registered_interfaces = interface;
+
+out:
+    uacpi_release_native_mutex(interface_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_uninstall_interface(const uacpi_char *name)
+{
+    struct registered_interface *cur, *prev;
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    cur = registered_interfaces;
+    prev = cur;
+
+    ret = UACPI_STATUS_NOT_FOUND;
+    while (cur) {
+        if (uacpi_strcmp(cur->name, name) != 0) {
+            prev = cur;
+            cur = cur->next;
+            continue;
+        }
+
+        if (cur->dynamic) {
+            if (prev == cur) {
+                registered_interfaces = cur->next;
+            } else {
+                prev->next = cur->next;
+            }
+
+            uacpi_release_native_mutex(interface_mutex);
+            uacpi_free_dynamic_string(cur->name);
+            uacpi_free(cur, sizeof(*cur));
+            return UACPI_STATUS_OK;
+        }
+
+        /*
+         * If this interface was already disabled, pretend we didn't actually
+         * find it and keep ret as UACPI_STATUS_NOT_FOUND. The fact that it's
+         * still in the registered list is an implementation detail of
+         * predefined interfaces.
+         */
+        if (!cur->disabled) {
+            cur->disabled = UACPI_TRUE;
+            ret = UACPI_STATUS_OK;
+        }
+
+        break;
+    }
+
+    uacpi_release_native_mutex(interface_mutex);
+    return ret;
+}
+
+static uacpi_status configure_host_interface(
+    uacpi_host_interface type, uacpi_bool enabled
+)
+{
+    struct registered_interface *interface;
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    interface = find_host_interface_unlocked(type);
+    if (interface == UACPI_NULL) {
+        ret = UACPI_STATUS_NOT_FOUND;
+        goto out;
+    }
+
+    interface->disabled = !enabled;
+out:
+    uacpi_release_native_mutex(interface_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_enable_host_interface(uacpi_host_interface type)
+{
+    return configure_host_interface(type, UACPI_TRUE);
+}
+
+uacpi_status uacpi_disable_host_interface(uacpi_host_interface type)
+{
+    return configure_host_interface(type, UACPI_FALSE);
+}
+
+uacpi_status uacpi_set_interface_query_handler(
+    uacpi_interface_handler handler
+)
+{
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (interface_handler != UACPI_NULL && handler != UACPI_NULL) {
+        ret = UACPI_STATUS_ALREADY_EXISTS;
+        goto out;
+    }
+
+    interface_handler = handler;
+out:
+    uacpi_release_native_mutex(interface_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_bulk_configure_interfaces(
+    uacpi_interface_action action, uacpi_interface_kind kind
+)
+{
+    uacpi_status ret;
+    struct registered_interface *interface;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    interface = registered_interfaces;
+    while (interface) {
+        if (kind & interface->kind)
+            interface->disabled = (action == UACPI_INTERFACE_ACTION_DISABLE);
+
+        interface = interface->next;
+    }
+
+    uacpi_release_native_mutex(interface_mutex);
+    return ret;
+}
+
+uacpi_status uacpi_handle_osi(const uacpi_char *string, uacpi_bool *out_value)
+{
+    uacpi_status ret;
+    struct registered_interface *interface;
+    uacpi_bool is_supported = UACPI_FALSE;
+
+    ret = uacpi_acquire_native_mutex(interface_mutex);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    interface = find_interface_unlocked(string);
+    if (interface == UACPI_NULL)
+        goto out;
+
+    if (interface->weight > latest_queried_interface)
+        uacpi_atomic_store32(&latest_queried_interface, interface->weight);
+
+    is_supported = !interface->disabled;
+    if (interface_handler)
+        is_supported = interface_handler(string, is_supported);
+out:
+    uacpi_release_native_mutex(interface_mutex);
+    *out_value = is_supported;
+    return UACPI_STATUS_OK;
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/registers.c

@@ -0,0 +1,572 @@
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/platform/atomic.h>
+#include <uacpi/acpi.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+static uacpi_handle g_reg_lock;
+
+enum register_kind {
+    REGISTER_KIND_GAS,
+    REGISTER_KIND_IO,
+};
+
+enum register_access_kind {
+    REGISTER_ACCESS_KIND_PRESERVE,
+    REGISTER_ACCESS_KIND_WRITE_TO_CLEAR,
+    REGISTER_ACCESS_KIND_NORMAL,
+};
+
+struct register_spec {
+    uacpi_u8 kind;
+    uacpi_u8 access_kind;
+    uacpi_u8 access_width; // only REGISTER_KIND_IO
+    void *accessors[2];
+    uacpi_u64 write_only_mask;
+    uacpi_u64 preserve_mask;
+};
+
+static const struct register_spec g_registers[UACPI_REGISTER_MAX + 1] = {
+    [UACPI_REGISTER_PM1_STS] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_WRITE_TO_CLEAR,
+        .accessors = {
+            &g_uacpi_rt_ctx.pm1a_status_blk,
+            &g_uacpi_rt_ctx.pm1b_status_blk,
+        },
+        .preserve_mask = ACPI_PM1_STS_IGN0_MASK,
+    },
+    [UACPI_REGISTER_PM1_EN] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_PRESERVE,
+        .accessors = {
+            &g_uacpi_rt_ctx.pm1a_enable_blk,
+            &g_uacpi_rt_ctx.pm1b_enable_blk,
+        },
+    },
+    [UACPI_REGISTER_PM1_CNT] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_PRESERVE,
+        .accessors = {
+            &g_uacpi_rt_ctx.fadt.x_pm1a_cnt_blk,
+            &g_uacpi_rt_ctx.fadt.x_pm1b_cnt_blk,
+        },
+        .write_only_mask = ACPI_PM1_CNT_SLP_EN_MASK |
+                           ACPI_PM1_CNT_GBL_RLS_MASK,
+        .preserve_mask = ACPI_PM1_CNT_PRESERVE_MASK,
+    },
+    [UACPI_REGISTER_PM_TMR] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_PRESERVE,
+        .accessors = { &g_uacpi_rt_ctx.fadt.x_pm_tmr_blk, },
+    },
+    [UACPI_REGISTER_PM2_CNT] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_PRESERVE,
+        .accessors = { &g_uacpi_rt_ctx.fadt.x_pm2_cnt_blk, },
+        .preserve_mask = ACPI_PM2_CNT_PRESERVE_MASK,
+    },
+    [UACPI_REGISTER_SLP_CNT] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_PRESERVE,
+        .accessors = { &g_uacpi_rt_ctx.fadt.sleep_control_reg, },
+        .write_only_mask = ACPI_SLP_CNT_SLP_EN_MASK,
+        .preserve_mask = ACPI_SLP_CNT_PRESERVE_MASK,
+    },
+    [UACPI_REGISTER_SLP_STS] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_WRITE_TO_CLEAR,
+        .accessors = { &g_uacpi_rt_ctx.fadt.sleep_status_reg, },
+        .preserve_mask = ACPI_SLP_STS_PRESERVE_MASK,
+    },
+    [UACPI_REGISTER_RESET] = {
+        .kind = REGISTER_KIND_GAS,
+        .access_kind = REGISTER_ACCESS_KIND_NORMAL,
+        .accessors = { &g_uacpi_rt_ctx.fadt.reset_reg, },
+    },
+    [UACPI_REGISTER_SMI_CMD] = {
+        .kind = REGISTER_KIND_IO,
+        .access_kind = REGISTER_ACCESS_KIND_NORMAL,
+        .access_width = 1,
+        .accessors = { &g_uacpi_rt_ctx.fadt.smi_cmd, },
+    },
+};
+
+enum register_mapping_state {
+   REGISTER_MAPPING_STATE_NONE = 0,
+   REGISTER_MAPPING_STATE_NOT_NEEDED,
+   REGISTER_MAPPING_STATE_MAPPED,
+};
+
+struct register_mapping {
+    uacpi_mapped_gas mappings[2];
+    uacpi_u8 states[2];
+};
+static struct register_mapping g_register_mappings[UACPI_REGISTER_MAX + 1];
+
+static uacpi_status map_one(
+    const struct register_spec *spec, struct register_mapping *mapping,
+    uacpi_u8 idx
+)
+{
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    if (mapping->states[idx] != REGISTER_MAPPING_STATE_NONE)
+        return ret;
+
+    if (spec->kind == REGISTER_KIND_GAS) {
+        struct acpi_gas *gas = spec->accessors[idx];
+
+        if (gas == UACPI_NULL || gas->address == 0) {
+            mapping->states[idx] = REGISTER_MAPPING_STATE_NOT_NEEDED;
+            return ret;
+        }
+
+        ret = uacpi_map_gas_noalloc(gas, &mapping->mappings[idx]);
+    } else {
+        if (idx != 0) {
+            mapping->states[idx] = REGISTER_MAPPING_STATE_NOT_NEEDED;
+            return ret;
+        }
+
+        struct acpi_gas temp_gas = {
+            .address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO,
+            .address = *(uacpi_u32*)spec->accessors[0],
+            .register_bit_width = spec->access_width * 8,
+        };
+
+        ret = uacpi_map_gas_noalloc(&temp_gas, &mapping->mappings[idx]);
+    }
+
+    if (uacpi_likely_success(ret))
+        mapping->states[idx] = REGISTER_MAPPING_STATE_MAPPED;
+
+    return ret;
+}
+
+static uacpi_status ensure_register_mapped(
+    const struct register_spec *spec, struct register_mapping *mapping
+)
+{
+    uacpi_status ret;
+    uacpi_bool needs_mapping = UACPI_FALSE;
+    uacpi_u8 state;
+    uacpi_cpu_flags flags;
+
+    state = uacpi_atomic_load8(&mapping->states[0]);
+    needs_mapping |= state == REGISTER_MAPPING_STATE_NONE;
+
+    state = uacpi_atomic_load8(&mapping->states[1]);
+    needs_mapping |= state == REGISTER_MAPPING_STATE_NONE;
+
+    if (!needs_mapping)
+        return UACPI_STATUS_OK;
+
+    flags = uacpi_kernel_lock_spinlock(g_reg_lock);
+
+    ret = map_one(spec, mapping, 0);
+    if (uacpi_unlikely_error(ret))
+        goto out;
+
+    ret = map_one(spec, mapping, 1);
+out:
+    uacpi_kernel_unlock_spinlock(g_reg_lock, flags);
+    return ret;
+}
+
+static uacpi_status get_reg(
+    uacpi_u8 idx, const struct register_spec **out_spec,
+    struct register_mapping **out_mapping
+)
+{
+    if (idx > UACPI_REGISTER_MAX)
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    *out_spec = &g_registers[idx];
+    *out_mapping = &g_register_mappings[idx];
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status do_read_one(
+    struct register_mapping *mapping, uacpi_u8 idx, uacpi_u64 *out_value
+)
+{
+    if (mapping->states[idx] != REGISTER_MAPPING_STATE_MAPPED)
+        return UACPI_STATUS_OK;
+
+    return uacpi_gas_read_mapped(&mapping->mappings[idx], out_value);
+}
+
+static uacpi_status do_read_register(
+    const struct register_spec *reg, struct register_mapping *mapping,
+    uacpi_u64 *out_value
+)
+{
+    uacpi_status ret;
+    uacpi_u64 value0 = 0, value1 = 0;
+
+    ret = do_read_one(mapping, 0, &value0);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = do_read_one(mapping, 1, &value1);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    *out_value = value0 | value1;
+    if (reg->write_only_mask)
+        *out_value &= ~reg->write_only_mask;
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_read_register(
+    enum uacpi_register reg_enum, uacpi_u64 *out_value
+)
+{
+    uacpi_status ret;
+    const struct register_spec *reg;
+    struct register_mapping *mapping;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = get_reg(reg_enum, &reg, &mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = ensure_register_mapped(reg, mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return do_read_register(reg, mapping, out_value);
+}
+
+static uacpi_status do_write_one(
+    struct register_mapping *mapping, uacpi_u8 idx, uacpi_u64 in_value
+)
+{
+    if (mapping->states[idx] != REGISTER_MAPPING_STATE_MAPPED)
+        return UACPI_STATUS_OK;
+
+    return uacpi_gas_write_mapped(&mapping->mappings[idx], in_value);
+}
+
+static uacpi_status do_write_register(
+    const struct register_spec *reg, struct register_mapping *mapping,
+    uacpi_u64 in_value
+)
+{
+    uacpi_status ret;
+
+    if (reg->preserve_mask) {
+        in_value &= ~reg->preserve_mask;
+
+        if (reg->access_kind == REGISTER_ACCESS_KIND_PRESERVE) {
+            uacpi_u64 data;
+
+            ret = do_read_register(reg, mapping, &data);
+            if (uacpi_unlikely_error(ret))
+                return ret;
+
+            in_value |= data & reg->preserve_mask;
+        }
+    }
+
+    ret = do_write_one(mapping, 0, in_value);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return do_write_one(mapping, 1, in_value);
+}
+
+uacpi_status uacpi_write_register(
+    enum uacpi_register reg_enum, uacpi_u64 in_value
+)
+{
+    uacpi_status ret;
+    const struct register_spec *reg;
+    struct register_mapping *mapping;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = get_reg(reg_enum, &reg, &mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = ensure_register_mapped(reg, mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return do_write_register(reg, mapping, in_value);
+}
+
+uacpi_status uacpi_write_registers(
+    enum uacpi_register reg_enum, uacpi_u64 in_value0, uacpi_u64 in_value1
+)
+{
+    uacpi_status ret;
+    const struct register_spec *reg;
+    struct register_mapping *mapping;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    ret = get_reg(reg_enum, &reg, &mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = ensure_register_mapped(reg, mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = do_write_one(mapping, 0, in_value0);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    return do_write_one(mapping, 1, in_value1);
+}
+
+struct register_field {
+    uacpi_u8 reg;
+    uacpi_u8 offset;
+    uacpi_u16 mask;
+};
+
+static const struct register_field g_fields[UACPI_REGISTER_FIELD_MAX + 1] = {
+    [UACPI_REGISTER_FIELD_TMR_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_TMR_STS_IDX,
+        .mask = ACPI_PM1_STS_TMR_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_BM_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_BM_STS_IDX,
+        .mask = ACPI_PM1_STS_BM_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_GBL_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_GBL_STS_IDX,
+        .mask = ACPI_PM1_STS_GBL_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_PWRBTN_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_PWRBTN_STS_IDX,
+        .mask = ACPI_PM1_STS_PWRBTN_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_SLPBTN_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_SLPBTN_STS_IDX,
+        .mask = ACPI_PM1_STS_SLPBTN_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_RTC_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_RTC_STS_IDX,
+        .mask = ACPI_PM1_STS_RTC_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_HWR_WAK_STS] = {
+        .reg = UACPI_REGISTER_SLP_STS,
+        .offset = ACPI_SLP_STS_WAK_STS_IDX,
+        .mask = ACPI_SLP_STS_WAK_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_WAK_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_WAKE_STS_IDX,
+        .mask = ACPI_PM1_STS_WAKE_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_PCIEX_WAKE_STS] = {
+        .reg = UACPI_REGISTER_PM1_STS,
+        .offset = ACPI_PM1_STS_PCIEXP_WAKE_STS_IDX,
+        .mask = ACPI_PM1_STS_PCIEXP_WAKE_STS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_TMR_EN] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_TMR_EN_IDX,
+        .mask = ACPI_PM1_EN_TMR_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_GBL_EN] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_GBL_EN_IDX,
+        .mask = ACPI_PM1_EN_GBL_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_PWRBTN_EN] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_PWRBTN_EN_IDX,
+        .mask = ACPI_PM1_EN_PWRBTN_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_SLPBTN_EN] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_SLPBTN_EN_IDX,
+        .mask = ACPI_PM1_EN_SLPBTN_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_RTC_EN] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_RTC_EN_IDX,
+        .mask = ACPI_PM1_EN_RTC_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_PCIEXP_WAKE_DIS] = {
+        .reg = UACPI_REGISTER_PM1_EN,
+        .offset = ACPI_PM1_EN_PCIEXP_WAKE_DIS_IDX,
+        .mask = ACPI_PM1_EN_PCIEXP_WAKE_DIS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_SCI_EN] = {
+        .reg = UACPI_REGISTER_PM1_CNT,
+        .offset = ACPI_PM1_CNT_SCI_EN_IDX,
+        .mask = ACPI_PM1_CNT_SCI_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_BM_RLD] = {
+        .reg = UACPI_REGISTER_PM1_CNT,
+        .offset = ACPI_PM1_CNT_BM_RLD_IDX,
+        .mask = ACPI_PM1_CNT_BM_RLD_MASK,
+    },
+    [UACPI_REGISTER_FIELD_GBL_RLS] = {
+        .reg = UACPI_REGISTER_PM1_CNT,
+        .offset = ACPI_PM1_CNT_GBL_RLS_IDX,
+        .mask = ACPI_PM1_CNT_GBL_RLS_MASK,
+    },
+    [UACPI_REGISTER_FIELD_SLP_TYP] = {
+        .reg = UACPI_REGISTER_PM1_CNT,
+        .offset = ACPI_PM1_CNT_SLP_TYP_IDX,
+        .mask = ACPI_PM1_CNT_SLP_TYP_MASK,
+    },
+    [UACPI_REGISTER_FIELD_SLP_EN] = {
+        .reg = UACPI_REGISTER_PM1_CNT,
+        .offset = ACPI_PM1_CNT_SLP_EN_IDX,
+        .mask = ACPI_PM1_CNT_SLP_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_HWR_SLP_TYP] = {
+        .reg = UACPI_REGISTER_SLP_CNT,
+        .offset = ACPI_SLP_CNT_SLP_TYP_IDX,
+        .mask = ACPI_SLP_CNT_SLP_TYP_MASK,
+    },
+    [UACPI_REGISTER_FIELD_HWR_SLP_EN] = {
+        .reg = UACPI_REGISTER_SLP_CNT,
+        .offset = ACPI_SLP_CNT_SLP_EN_IDX,
+        .mask = ACPI_SLP_CNT_SLP_EN_MASK,
+    },
+    [UACPI_REGISTER_FIELD_ARB_DIS] = {
+        .reg = UACPI_REGISTER_PM2_CNT,
+        .offset = ACPI_PM2_CNT_ARB_DIS_IDX,
+        .mask = ACPI_PM2_CNT_ARB_DIS_MASK,
+    },
+};
+
+uacpi_status uacpi_initialize_registers(void)
+{
+    g_reg_lock = uacpi_kernel_create_spinlock();
+    if (uacpi_unlikely(g_reg_lock == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    return UACPI_STATUS_OK;
+}
+
+void uacpi_deinitialize_registers(void)
+{
+    uacpi_u8 i;
+    struct register_mapping *mapping;
+
+    if (g_reg_lock != UACPI_NULL) {
+        uacpi_kernel_free_spinlock(g_reg_lock);
+        g_reg_lock = UACPI_NULL;
+    }
+
+    for (i = 0; i <= UACPI_REGISTER_MAX; ++i) {
+        mapping = &g_register_mappings[i];
+
+        if (mapping->states[0] == REGISTER_MAPPING_STATE_MAPPED)
+            uacpi_unmap_gas_nofree(&mapping->mappings[0]);
+        if (mapping->states[1] == REGISTER_MAPPING_STATE_MAPPED)
+            uacpi_unmap_gas_nofree(&mapping->mappings[1]);
+    }
+
+    uacpi_memzero(&g_register_mappings, sizeof(g_register_mappings));
+}
+
+uacpi_status uacpi_read_register_field(
+    enum uacpi_register_field field_enum, uacpi_u64 *out_value
+)
+{
+    uacpi_status ret;
+    uacpi_u8 field_idx = field_enum;
+    const struct register_field *field;
+    const struct register_spec *reg;
+    struct register_mapping *mapping;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(field_idx > UACPI_REGISTER_FIELD_MAX))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    field = &g_fields[field_idx];
+    reg = &g_registers[field->reg];
+    mapping = &g_register_mappings[field->reg];
+
+    ret = ensure_register_mapped(reg, mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = do_read_register(reg, mapping, out_value);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    *out_value = (*out_value & field->mask) >> field->offset;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_write_register_field(
+    enum uacpi_register_field field_enum, uacpi_u64 in_value
+)
+{
+    uacpi_status ret;
+    uacpi_u8 field_idx = field_enum;
+    const struct register_field *field;
+    const struct register_spec *reg;
+    struct register_mapping *mapping;
+
+    uacpi_u64 data;
+    uacpi_cpu_flags flags;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_unlikely(field_idx > UACPI_REGISTER_FIELD_MAX))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    field = &g_fields[field_idx];
+    reg = &g_registers[field->reg];
+    mapping = &g_register_mappings[field->reg];
+
+    ret = ensure_register_mapped(reg, mapping);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    in_value = (in_value << field->offset) & field->mask;
+
+    flags = uacpi_kernel_lock_spinlock(g_reg_lock);
+
+    if (reg->kind == REGISTER_ACCESS_KIND_WRITE_TO_CLEAR) {
+        if (in_value == 0) {
+            ret = UACPI_STATUS_OK;
+            goto out;
+        }
+
+        ret = do_write_register(reg, mapping, in_value);
+        goto out;
+    }
+
+    ret = do_read_register(reg, mapping, &data);
+    if (uacpi_unlikely_error(ret))
+        goto out;
+
+    data &= ~field->mask;
+    data |= in_value;
+
+    ret = do_write_register(reg, mapping, data);
+
+out:
+    uacpi_kernel_unlock_spinlock(g_reg_lock, flags);
+    return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/shareable.c

@@ -0,0 +1,71 @@
+#include <uacpi/internal/shareable.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/platform/atomic.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define BUGGED_REFCOUNT 0xFFFFFFFF
+
+void uacpi_shareable_init(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+    shareable->reference_count = 1;
+}
+
+uacpi_bool uacpi_bugged_shareable(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+
+    if (uacpi_unlikely(shareable->reference_count == 0))
+        uacpi_make_shareable_bugged(shareable);
+
+    return uacpi_atomic_load32(&shareable->reference_count) == BUGGED_REFCOUNT;
+}
+
+void uacpi_make_shareable_bugged(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+    uacpi_atomic_store32(&shareable->reference_count, BUGGED_REFCOUNT);
+}
+
+uacpi_u32 uacpi_shareable_ref(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+
+    if (uacpi_unlikely(uacpi_bugged_shareable(shareable)))
+        return BUGGED_REFCOUNT;
+
+    return uacpi_atomic_inc32(&shareable->reference_count) - 1;
+}
+
+uacpi_u32 uacpi_shareable_unref(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+
+    if (uacpi_unlikely(uacpi_bugged_shareable(shareable)))
+        return BUGGED_REFCOUNT;
+
+    return uacpi_atomic_dec32(&shareable->reference_count) + 1;
+}
+
+void uacpi_shareable_unref_and_delete_if_last(
+    uacpi_handle handle, void (*do_free)(uacpi_handle)
+)
+{
+    if (handle == UACPI_NULL)
+        return;
+
+    if (uacpi_unlikely(uacpi_bugged_shareable(handle)))
+        return;
+
+    if (uacpi_shareable_unref(handle) == 1)
+        do_free(handle);
+}
+
+uacpi_u32 uacpi_shareable_refcount(uacpi_handle handle)
+{
+    struct uacpi_shareable *shareable = handle;
+    return uacpi_atomic_load32(&shareable->reference_count);
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/sleep.c

@@ -0,0 +1,616 @@
+#include <uacpi/sleep.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/event.h>
+#include <uacpi/platform/arch_helpers.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+#define CALL_SLEEP_FN(name, state)                       \
+    (uacpi_is_hardware_reduced() ?                       \
+        name##_hw_reduced(state) : name##_hw_full(state))
+#else
+#define CALL_SLEEP_FN(name, state) name##_hw_reduced(state);
+#endif
+
+static uacpi_status eval_wak(uacpi_u8 state);
+static uacpi_status eval_sst(uacpi_u8 value);
+
+#ifndef UACPI_REDUCED_HARDWARE
+uacpi_status uacpi_set_waking_vector(
+    uacpi_phys_addr addr32, uacpi_phys_addr addr64
+)
+{
+    struct acpi_facs *facs = g_uacpi_rt_ctx.facs;
+
+    if (facs == UACPI_NULL)
+        return UACPI_STATUS_OK;
+
+    facs->firmware_waking_vector = addr32;
+
+    // The 64-bit wake vector doesn't exist, we're done
+    if (facs->length < 32)
+        return UACPI_STATUS_OK;
+
+    // Only allow 64-bit wake vector on 1.0 and above FACS
+    if (facs->version >= 1)
+        facs->x_firmware_waking_vector = addr64;
+    else
+        facs->x_firmware_waking_vector = 0;
+
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status enter_sleep_state_hw_full(uacpi_u8 state)
+{
+    uacpi_status ret;
+    uacpi_u64 wake_status, pm1a, pm1b;
+
+    ret = uacpi_write_register_field(
+        UACPI_REGISTER_FIELD_WAK_STS, ACPI_PM1_STS_CLEAR
+    );
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_disable_all_gpes();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_clear_all_events();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_enable_all_wake_gpes();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_read_register(UACPI_REGISTER_PM1_CNT, &pm1a);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    pm1a &= ~((uacpi_u64)(ACPI_PM1_CNT_SLP_TYP_MASK | ACPI_PM1_CNT_SLP_EN_MASK));
+    pm1b = pm1a;
+
+    pm1a |= g_uacpi_rt_ctx.last_sleep_typ_a << ACPI_PM1_CNT_SLP_TYP_IDX;
+    pm1b |= g_uacpi_rt_ctx.last_sleep_typ_b << ACPI_PM1_CNT_SLP_TYP_IDX;
+
+    /*
+     * Just like ACPICA, split writing SLP_TYP and SLP_EN to work around
+     * buggy firmware that can't handle both written at the same time.
+     */
+    ret = uacpi_write_registers(UACPI_REGISTER_PM1_CNT, pm1a, pm1b);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    pm1a |= ACPI_PM1_CNT_SLP_EN_MASK;
+    pm1b |= ACPI_PM1_CNT_SLP_EN_MASK;
+
+    if (state < UACPI_SLEEP_STATE_S4)
+        UACPI_ARCH_FLUSH_CPU_CACHE();
+
+    ret = uacpi_write_registers(UACPI_REGISTER_PM1_CNT, pm1a, pm1b);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (state > UACPI_SLEEP_STATE_S3) {
+        /*
+         * We're still here, this is a bug or very slow firmware.
+         * Just try spinning for a bit.
+         */
+        uacpi_u64 stalled_time = 0;
+
+        // 10 seconds max
+        while (stalled_time < (10 * 1000 * 1000)) {
+            uacpi_kernel_stall(100);
+            stalled_time += 100;
+        }
+
+        // Try one more time
+        ret = uacpi_write_registers(UACPI_REGISTER_PM1_CNT, pm1a, pm1b);
+        if (uacpi_unlikely_error(ret))
+            return ret;
+
+        // Nothing we can do here, give up
+        return UACPI_STATUS_HARDWARE_TIMEOUT;
+    }
+
+    do {
+        ret = uacpi_read_register_field(
+            UACPI_REGISTER_FIELD_WAK_STS, &wake_status
+        );
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    } while (wake_status != 1);
+
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status prepare_for_wake_from_sleep_state_hw_full(uacpi_u8 state)
+{
+    uacpi_status ret;
+    uacpi_u64 pm1a, pm1b;
+    UACPI_UNUSED(state);
+
+    /*
+     * Some hardware apparently relies on S0 values being written to the PM1
+     * control register on wake, so do this here.
+     */
+
+    if (g_uacpi_rt_ctx.s0_sleep_typ_a == UACPI_SLEEP_TYP_INVALID)
+        goto out;
+
+    ret = uacpi_read_register(UACPI_REGISTER_PM1_CNT, &pm1a);
+    if (uacpi_unlikely_error(ret))
+        goto out;
+
+    pm1a &= ~((uacpi_u64)(ACPI_PM1_CNT_SLP_TYP_MASK | ACPI_PM1_CNT_SLP_EN_MASK));
+    pm1b = pm1a;
+
+    pm1a |= g_uacpi_rt_ctx.s0_sleep_typ_a << ACPI_PM1_CNT_SLP_TYP_IDX;
+    pm1b |= g_uacpi_rt_ctx.s0_sleep_typ_b << ACPI_PM1_CNT_SLP_TYP_IDX;
+
+    uacpi_write_registers(UACPI_REGISTER_PM1_CNT, pm1a, pm1b);
+out:
+    // Errors ignored intentionally, we don't want to abort because of this
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status wake_from_sleep_state_hw_full(uacpi_u8 state)
+{
+    uacpi_status ret;
+    g_uacpi_rt_ctx.last_sleep_typ_a = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.last_sleep_typ_b = UACPI_SLEEP_TYP_INVALID;
+
+    // Set the status to 2 (waking) while we execute the wake method.
+    eval_sst(2);
+
+    ret = uacpi_disable_all_gpes();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    ret = uacpi_enable_all_runtime_gpes();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    eval_wak(state);
+
+    // Apparently some BIOSes expect us to clear this, so do it
+    uacpi_write_register_field(
+        UACPI_REGISTER_FIELD_WAK_STS, ACPI_PM1_STS_CLEAR
+    );
+
+    // Now that we're awake set the status to 1 (running)
+    eval_sst(1);
+
+    return UACPI_STATUS_OK;
+}
+#endif
+
+static uacpi_status get_slp_type_for_state(
+    uacpi_u8 state, uacpi_u8 *a, uacpi_u8 *b
+)
+{
+    uacpi_char path[] = "_S0";
+    uacpi_status ret;
+    uacpi_object *obj0, *obj1, *ret_obj = UACPI_NULL;
+
+    path[2] += state;
+
+    ret = uacpi_eval_typed(
+        uacpi_namespace_root(), path, UACPI_NULL,
+        UACPI_OBJECT_PACKAGE_BIT, &ret_obj
+    );
+    if (ret != UACPI_STATUS_OK) {
+        if (uacpi_unlikely(ret != UACPI_STATUS_NOT_FOUND)) {
+            uacpi_warn("error while evaluating %s: %s\n", path,
+                       uacpi_status_to_string(ret));
+        } else {
+            uacpi_trace("sleep state %d is not supported as %s was not found\n",
+                        state, path);
+        }
+        goto out;
+    }
+
+    switch (ret_obj->package->count) {
+    case 0:
+        uacpi_error("empty package while evaluating %s!\n", path);
+        ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+        goto out;
+
+    case 1:
+        obj0 = ret_obj->package->objects[0];
+        if (uacpi_unlikely(obj0->type != UACPI_OBJECT_INTEGER)) {
+            uacpi_error(
+                "invalid object type at pkg[0] => %s when evaluating %s\n",
+                uacpi_object_type_to_string(obj0->type), path
+            );
+            goto out;
+        }
+
+        *a = obj0->integer;
+        *b = obj0->integer >> 8;
+        break;
+
+    default:
+        obj0 = ret_obj->package->objects[0];
+        obj1 = ret_obj->package->objects[1];
+
+        if (uacpi_unlikely(obj0->type != UACPI_OBJECT_INTEGER ||
+                           obj1->type != UACPI_OBJECT_INTEGER)) {
+            uacpi_error(
+                "invalid object type when evaluating %s: "
+                "pkg[0] => %s, pkg[1] => %s\n", path,
+                uacpi_object_type_to_string(obj0->type),
+                uacpi_object_type_to_string(obj1->type)
+            );
+            ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+            goto out;
+        }
+
+        *a = obj0->integer;
+        *b = obj1->integer;
+        break;
+    }
+
+out:
+    if (ret != UACPI_STATUS_OK) {
+        *a = UACPI_SLEEP_TYP_INVALID;
+        *b = UACPI_SLEEP_TYP_INVALID;
+    }
+
+    uacpi_object_unref(ret_obj);
+    return ret;
+}
+
+static uacpi_status eval_sleep_helper(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_u8 value
+)
+{
+    uacpi_object *arg;
+    uacpi_object_array args;
+    uacpi_status ret;
+
+    arg = uacpi_create_object(UACPI_OBJECT_INTEGER);
+    if (uacpi_unlikely(arg == UACPI_NULL))
+        return UACPI_STATUS_OUT_OF_MEMORY;
+
+    arg->integer = value;
+    args.objects = &arg;
+    args.count = 1;
+
+    ret = uacpi_eval(parent, path, &args, UACPI_NULL);
+    switch (ret) {
+    case UACPI_STATUS_OK:
+        break;
+    case UACPI_STATUS_NOT_FOUND:
+        ret = UACPI_STATUS_OK;
+        break;
+    default:
+        uacpi_error("error while evaluating %s: %s\n",
+                    path, uacpi_status_to_string(ret));
+        break;
+    }
+
+    uacpi_object_unref(arg);
+    return ret;
+}
+
+static uacpi_status eval_pts(uacpi_u8 state)
+{
+    return eval_sleep_helper(uacpi_namespace_root(), "_PTS", state);
+}
+
+static uacpi_status eval_wak(uacpi_u8 state)
+{
+    return eval_sleep_helper(uacpi_namespace_root(), "_WAK", state);
+}
+
+static uacpi_status eval_sst(uacpi_u8 value)
+{
+    return eval_sleep_helper(
+        uacpi_namespace_get_predefined(UACPI_PREDEFINED_NAMESPACE_SI),
+        "_SST", value
+    );
+}
+
+static uacpi_status eval_sst_for_state(enum uacpi_sleep_state state)
+{
+    uacpi_u8 arg;
+
+    /*
+     * This optional object is a control method that OSPM invokes to set the
+     * system status indicator as desired.
+     * Arguments:(1)
+     * Arg0 - An Integer containing the system status indicator identifier:
+     *     0 - No system state indication. Indicator off
+     *     1 - Working
+     *     2 - Waking
+     *     3 - Sleeping. Used to indicate system state S1, S2, or S3
+     *     4 - Sleeping with context saved to non-volatile storage
+     */
+    switch (state) {
+    case UACPI_SLEEP_STATE_S0:
+        arg = 1;
+        break;
+    case UACPI_SLEEP_STATE_S1:
+    case UACPI_SLEEP_STATE_S2:
+    case UACPI_SLEEP_STATE_S3:
+        arg = 3;
+        break;
+    case UACPI_SLEEP_STATE_S4:
+        arg = 4;
+        break;
+    case UACPI_SLEEP_STATE_S5:
+        arg = 0;
+        break;
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+
+    return eval_sst(arg);
+}
+
+uacpi_status uacpi_prepare_for_sleep_state(enum uacpi_sleep_state state_enum)
+{
+    uacpi_u8 state = state_enum;
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
+
+    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_S5))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = get_slp_type_for_state(
+        state,
+        &g_uacpi_rt_ctx.last_sleep_typ_a,
+        &g_uacpi_rt_ctx.last_sleep_typ_b
+    );
+    if (ret != UACPI_STATUS_OK)
+        return ret;
+
+    ret = get_slp_type_for_state(
+        0,
+        &g_uacpi_rt_ctx.s0_sleep_typ_a,
+        &g_uacpi_rt_ctx.s0_sleep_typ_b
+    );
+
+    ret = eval_pts(state);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    eval_sst_for_state(state);
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_u8 make_hw_reduced_sleep_control(uacpi_u8 slp_typ)
+{
+    uacpi_u8 value;
+
+    value = (slp_typ << ACPI_SLP_CNT_SLP_TYP_IDX);
+    value &= ACPI_SLP_CNT_SLP_TYP_MASK;
+    value |= ACPI_SLP_CNT_SLP_EN_MASK;
+
+    return value;
+}
+
+static uacpi_status enter_sleep_state_hw_reduced(uacpi_u8 state)
+{
+    uacpi_status ret;
+    uacpi_u8 sleep_control;
+    uacpi_u64 wake_status;
+    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+
+    if (!fadt->sleep_control_reg.address || !fadt->sleep_status_reg.address)
+        return UACPI_STATUS_NOT_FOUND;
+
+    ret = uacpi_write_register_field(
+        UACPI_REGISTER_FIELD_HWR_WAK_STS,
+        ACPI_SLP_STS_CLEAR
+    );
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    sleep_control = make_hw_reduced_sleep_control(
+        g_uacpi_rt_ctx.last_sleep_typ_a
+    );
+
+    if (state < UACPI_SLEEP_STATE_S4)
+        UACPI_ARCH_FLUSH_CPU_CACHE();
+
+    /*
+     * To put the system into a sleep state, software will write the HW-reduced
+     * Sleep Type value (obtained from the \_Sx object in the DSDT) and the
+     * SLP_EN bit to the sleep control register.
+     */
+    ret = uacpi_write_register(UACPI_REGISTER_SLP_CNT, sleep_control);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    /*
+     * The OSPM then polls the WAK_STS bit of the SLEEP_STATUS_REG waiting for
+     * it to be one (1), indicating that the system has been transitioned
+     * back to the Working state.
+     */
+    do {
+        ret = uacpi_read_register_field(
+            UACPI_REGISTER_FIELD_HWR_WAK_STS, &wake_status
+        );
+        if (uacpi_unlikely_error(ret))
+            return ret;
+    } while (wake_status != 1);
+
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status prepare_for_wake_from_sleep_state_hw_reduced(uacpi_u8 state)
+{
+    uacpi_u8 sleep_control;
+    UACPI_UNUSED(state);
+
+    if (g_uacpi_rt_ctx.s0_sleep_typ_a == UACPI_SLEEP_TYP_INVALID)
+        goto out;
+
+    sleep_control = make_hw_reduced_sleep_control(
+        g_uacpi_rt_ctx.s0_sleep_typ_a
+    );
+    uacpi_write_register(UACPI_REGISTER_SLP_CNT, sleep_control);
+
+out:
+    return UACPI_STATUS_OK;
+}
+
+static uacpi_status wake_from_sleep_state_hw_reduced(uacpi_u8 state)
+{
+    g_uacpi_rt_ctx.last_sleep_typ_a = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.last_sleep_typ_b = UACPI_SLEEP_TYP_INVALID;
+
+    // Set the status to 2 (waking) while we execute the wake method.
+    eval_sst(2);
+
+    eval_wak(state);
+
+    // Apparently some BIOSes expect us to clear this, so do it
+    uacpi_write_register_field(
+        UACPI_REGISTER_FIELD_HWR_WAK_STS, ACPI_SLP_STS_CLEAR
+    );
+
+    // Now that we're awake set the status to 1 (running)
+    eval_sst(1);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_enter_sleep_state(enum uacpi_sleep_state state_enum)
+{
+    uacpi_u8 state = state_enum;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
+
+    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    if (uacpi_unlikely(g_uacpi_rt_ctx.last_sleep_typ_a > ACPI_SLP_TYP_MAX ||
+                       g_uacpi_rt_ctx.last_sleep_typ_b > ACPI_SLP_TYP_MAX)) {
+        uacpi_error("invalid SLP_TYP values: 0x%02X:0x%02X\n",
+                    g_uacpi_rt_ctx.last_sleep_typ_a,
+                    g_uacpi_rt_ctx.last_sleep_typ_b);
+        return UACPI_STATUS_AML_BAD_ENCODING;
+    }
+
+    return CALL_SLEEP_FN(enter_sleep_state, state);
+}
+
+uacpi_status uacpi_prepare_for_wake_from_sleep_state(
+    uacpi_sleep_state state_enum
+)
+{
+    uacpi_u8 state = state_enum;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
+
+    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    return CALL_SLEEP_FN(prepare_for_wake_from_sleep_state, state);
+}
+
+uacpi_status uacpi_wake_from_sleep_state(
+    uacpi_sleep_state state_enum
+)
+{
+    uacpi_u8 state = state_enum;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
+
+    if (uacpi_unlikely(state > UACPI_SLEEP_STATE_MAX))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    return CALL_SLEEP_FN(wake_from_sleep_state, state);
+}
+
+uacpi_status uacpi_reboot(void)
+{
+    uacpi_status ret;
+    uacpi_handle pci_dev = UACPI_NULL, io_handle = UACPI_NULL;
+    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+    struct acpi_gas *reset_reg = &fadt->reset_reg;
+
+    /*
+     * Allow restarting earlier than namespace load so that the kernel can
+     * use this in case of some initialization error.
+     */
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (!(fadt->flags & ACPI_RESET_REG_SUP) || !reset_reg->address)
+        return UACPI_STATUS_NOT_FOUND;
+
+    switch (reset_reg->address_space_id) {
+    case UACPI_ADDRESS_SPACE_SYSTEM_IO:
+        /*
+         * For SystemIO we don't do any checking, and we ignore bit width
+         * because that's what NT does.
+         */
+        ret = uacpi_kernel_io_map(reset_reg->address, 1, &io_handle);
+        if (uacpi_unlikely_error(ret))
+            return ret;
+
+        ret = uacpi_kernel_io_write8(io_handle, 0, fadt->reset_value);
+        break;
+    case UACPI_ADDRESS_SPACE_SYSTEM_MEMORY:
+        ret = uacpi_write_register(UACPI_REGISTER_RESET, fadt->reset_value);
+        break;
+    case UACPI_ADDRESS_SPACE_PCI_CONFIG: {
+        // Bus is assumed to be 0 here
+        uacpi_pci_address address = {
+            .segment = 0,
+            .bus = 0,
+            .device = (reset_reg->address >> 32) & 0xFF,
+            .function = (reset_reg->address >> 16) & 0xFF,
+        };
+
+        ret = uacpi_kernel_pci_device_open(address, &pci_dev);
+        if (uacpi_unlikely_error(ret))
+            break;
+
+        ret = uacpi_kernel_pci_write8(
+            pci_dev, reset_reg->address & 0xFFFF, fadt->reset_value
+        );
+        break;
+    }
+    default:
+        uacpi_warn(
+            "unable to perform a reset: unsupported address space '%s' (%d)\n",
+            uacpi_address_space_to_string(reset_reg->address_space_id),
+            reset_reg->address_space_id
+        );
+        ret = UACPI_STATUS_UNIMPLEMENTED;
+    }
+
+    if (ret == UACPI_STATUS_OK) {
+        /*
+         * This should've worked but we're still here.
+         * Spin for a bit then give up.
+         */
+        uacpi_u64 stalled_time = 0;
+
+        while (stalled_time < (1000 * 1000)) {
+            uacpi_kernel_stall(100);
+            stalled_time += 100;
+        }
+
+        uacpi_error("reset timeout\n");
+        ret = UACPI_STATUS_HARDWARE_TIMEOUT;
+    }
+
+    if (pci_dev != UACPI_NULL)
+        uacpi_kernel_pci_device_close(pci_dev);
+    if (io_handle != UACPI_NULL)
+        uacpi_kernel_io_unmap(io_handle);
+
+    return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE

drivers/bus/acpi_new/uacpi/source/stdlib.c

@@ -0,0 +1,705 @@
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/utilities.h>
+
+#ifdef UACPI_USE_BUILTIN_STRING
+
+#ifndef uacpi_memcpy
+void *uacpi_memcpy(void *dest, const void *src, uacpi_size count)
+{
+    uacpi_char *cd = dest;
+    const uacpi_char *cs = src;
+
+    while (count--)
+        *cd++ = *cs++;
+
+    return dest;
+}
+#endif
+
+#ifndef uacpi_memmove
+void *uacpi_memmove(void *dest, const void *src, uacpi_size count)
+{
+    uacpi_char *cd = dest;
+    const uacpi_char *cs = src;
+
+    if (src < dest) {
+        cs += count;
+        cd += count;
+
+        while (count--)
+            *--cd = *--cs;
+    } else {
+        while (count--)
+            *cd++ = *cs++;
+    }
+
+    return dest;
+}
+#endif
+
+#ifndef uacpi_memset
+void *uacpi_memset(void *dest, uacpi_i32 ch, uacpi_size count)
+{
+    uacpi_u8 fill = ch;
+    uacpi_u8 *cdest = dest;
+
+    while (count--)
+        *cdest++ = fill;
+
+    return dest;
+}
+#endif
+
+#ifndef uacpi_memcmp
+uacpi_i32 uacpi_memcmp(const void *lhs, const void *rhs, uacpi_size count)
+{
+    const uacpi_u8 *byte_lhs = lhs;
+    const uacpi_u8 *byte_rhs = rhs;
+    uacpi_size i;
+
+    for (i = 0; i < count; ++i) {
+        if (byte_lhs[i] != byte_rhs[i])
+            return byte_lhs[i] - byte_rhs[i];
+    }
+
+    return 0;
+}
+#endif
+
+#endif // UACPI_USE_BUILTIN_STRING
+
+#ifndef uacpi_strlen
+uacpi_size uacpi_strlen(const uacpi_char *str)
+{
+    const uacpi_char *str1;
+
+    for (str1 = str; *str1; str1++);
+
+    return str1 - str;
+}
+#endif
+
+#ifndef UACPI_BAREBONES_MODE
+
+#ifndef uacpi_strnlen
+uacpi_size uacpi_strnlen(const uacpi_char *str, uacpi_size max)
+{
+    const uacpi_char *str1;
+
+    for (str1 = str; max-- && *str1; str1++);
+
+    return str1 - str;
+}
+#endif
+
+#ifndef uacpi_strcmp
+uacpi_i32 uacpi_strcmp(const uacpi_char *lhs, const uacpi_char *rhs)
+{
+    uacpi_size i = 0;
+    typedef const uacpi_u8 *cucp;
+
+    while (lhs[i] && rhs[i]) {
+        if (lhs[i] != rhs[i])
+            return *(cucp)&lhs[i] - *(cucp)&rhs[i];
+
+        i++;
+    }
+
+    return *(cucp)&lhs[i] - *(cucp)&rhs[i];
+}
+#endif
+
+void uacpi_memcpy_zerout(void *dst, const void *src,
+    uacpi_size dst_size, uacpi_size src_size)
+{
+    uacpi_size bytes_to_copy = UACPI_MIN(src_size, dst_size);
+
+    if (bytes_to_copy)
+        uacpi_memcpy(dst, src, bytes_to_copy);
+
+    if (dst_size > bytes_to_copy)
+        uacpi_memzero((uacpi_u8 *)dst + bytes_to_copy, dst_size - bytes_to_copy);
+}
+
+uacpi_u8 uacpi_bit_scan_forward(uacpi_u64 value)
+{
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned char ret;
+    unsigned long index;
+
+#ifdef _WIN64
+    ret = _BitScanForward64(&index, value);
+    if (ret == 0)
+        return 0;
+
+    return (uacpi_u8)index + 1;
+#else
+    ret = _BitScanForward(&index, value);
+    if (ret == 0) {
+        ret = _BitScanForward(&index, value >> 32);
+        if (ret == 0)
+            return 0;
+
+        return (uacpi_u8)index + 33;
+    }
+
+    return (uacpi_u8)index + 1;
+#endif
+
+#else
+    return __builtin_ffsll(value);
+#endif
+}
+
+uacpi_u8 uacpi_bit_scan_backward(uacpi_u64 value)
+{
+#if defined(_MSC_VER) && !defined(__clang__)
+    unsigned char ret;
+    unsigned long index;
+
+#ifdef _WIN64
+    ret = _BitScanReverse64(&index, value);
+    if (ret == 0)
+        return 0;
+
+    return (uacpi_u8)index + 1;
+#else
+    ret = _BitScanReverse(&index, value >> 32);
+    if (ret == 0) {
+        ret = _BitScanReverse(&index, value);
+        if (ret == 0)
+            return 0;
+
+        return (uacpi_u8)index + 1;
+    }
+
+    return (uacpi_u8)index + 33;
+#endif
+
+#else
+    if (value == 0)
+        return 0;
+
+    return 64 - __builtin_clzll(value);
+#endif
+}
+
+#ifndef UACPI_NATIVE_ALLOC_ZEROED
+void *uacpi_builtin_alloc_zeroed(uacpi_size size)
+{
+    void *ptr;
+
+    ptr = uacpi_kernel_alloc(size);
+    if (uacpi_unlikely(ptr == UACPI_NULL))
+        return ptr;
+
+    uacpi_memzero(ptr, size);
+    return ptr;
+}
+#endif
+
+#endif // !UACPI_BAREBONES_MODE
+
+#ifndef uacpi_vsnprintf
+struct fmt_buf_state {
+    uacpi_char *buffer;
+    uacpi_size capacity;
+    uacpi_size bytes_written;
+};
+
+struct fmt_spec {
+    uacpi_u8 is_signed      : 1;
+    uacpi_u8 prepend        : 1;
+    uacpi_u8 uppercase      : 1;
+    uacpi_u8 left_justify   : 1;
+    uacpi_u8 alternate_form : 1;
+    uacpi_u8 has_precision  : 1;
+    uacpi_char pad_char;
+    uacpi_char prepend_char;
+    uacpi_u64 min_width;
+    uacpi_u64 precision;
+    uacpi_u32 base;
+};
+
+static void write_one(struct fmt_buf_state *fb_state, uacpi_char c)
+{
+    if (fb_state->bytes_written < fb_state->capacity)
+        fb_state->buffer[fb_state->bytes_written] = c;
+
+    fb_state->bytes_written++;
+}
+
+static void write_many(
+    struct fmt_buf_state *fb_state, const uacpi_char *string, uacpi_size count
+)
+{
+    if (fb_state->bytes_written < fb_state->capacity) {
+        uacpi_size count_to_write;
+
+        count_to_write = UACPI_MIN(
+            count, fb_state->capacity - fb_state->bytes_written
+        );
+        uacpi_memcpy(
+            &fb_state->buffer[fb_state->bytes_written], string, count_to_write
+        );
+    }
+
+    fb_state->bytes_written += count;
+}
+
+static uacpi_char hex_char(uacpi_bool upper, uacpi_u64 value)
+{
+    static const uacpi_char upper_hex[] = "0123456789ABCDEF";
+    static const uacpi_char lower_hex[] = "0123456789abcdef";
+
+    return (upper ? upper_hex : lower_hex)[value];
+}
+
+static void write_padding(
+    struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_size repr_size
+)
+{
+    uacpi_u64 mw = fm->min_width;
+
+    if (mw <= repr_size)
+        return;
+
+    mw -= repr_size;
+
+    while (mw--)
+        write_one(fb_state, fm->left_justify ? ' ' : fm->pad_char);
+}
+
+#define REPR_BUFFER_SIZE 32
+
+static void write_integer(
+    struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_u64 value
+)
+{
+    uacpi_char repr_buffer[REPR_BUFFER_SIZE];
+    uacpi_size index = REPR_BUFFER_SIZE;
+    uacpi_u64 remainder;
+    uacpi_char repr;
+    uacpi_bool negative = UACPI_FALSE;
+    uacpi_size repr_size;
+
+    if (fm->is_signed) {
+        uacpi_i64 as_ll = value;
+
+        if (as_ll < 0) {
+            value = -as_ll;
+            negative = UACPI_TRUE;
+        }
+    }
+
+    if (fm->prepend || negative)
+        write_one(fb_state, negative ? '-' : fm->prepend_char);
+
+    while (value) {
+        remainder = value % fm->base;
+        value /= fm->base;
+
+        if (fm->base == 16) {
+            repr = hex_char(fm->uppercase, remainder);
+        } else if (fm->base == 8 || fm->base == 10) {
+            repr = remainder + '0';
+        } else {
+            repr = '?';
+        }
+
+        repr_buffer[--index] = repr;
+    }
+    repr_size = REPR_BUFFER_SIZE - index;
+
+    if (repr_size == 0) {
+        repr_buffer[--index] = '0';
+        repr_size = 1;
+    }
+
+    if (fm->alternate_form) {
+        if (fm->base == 16) {
+            repr_buffer[--index] = fm->uppercase ? 'X' : 'x';
+            repr_buffer[--index] = '0';
+            repr_size += 2;
+        } else if (fm->base == 8) {
+            repr_buffer[--index] = '0';
+            repr_size += 1;
+        }
+    }
+
+    if (fm->left_justify) {
+        write_many(fb_state, &repr_buffer[index], repr_size);
+        write_padding(fb_state, fm, repr_size);
+    } else {
+        write_padding(fb_state, fm, repr_size);
+        write_many(fb_state, &repr_buffer[index], repr_size);
+    }
+}
+
+static uacpi_bool string_has_at_least(
+    const uacpi_char *string, uacpi_size characters
+)
+{
+    while (*string) {
+        if (--characters == 0)
+            return UACPI_TRUE;
+
+        string++;
+    }
+
+    return UACPI_FALSE;
+}
+
+static uacpi_bool consume_digits(
+    const uacpi_char **string, uacpi_size *out_size
+)
+{
+    uacpi_size size = 0;
+
+    for (;;) {
+        char c = **string;
+        if (c < '0' || c > '9')
+            break;
+
+        size++;
+        *string += 1;
+    }
+
+    if (size == 0)
+        return UACPI_FALSE;
+
+    *out_size = size;
+    return UACPI_TRUE;
+}
+
+enum parse_number_mode {
+    PARSE_NUMBER_MODE_MAYBE,
+    PARSE_NUMBER_MODE_MUST,
+};
+
+static uacpi_bool parse_number(
+    const uacpi_char **fmt, enum parse_number_mode mode, uacpi_u64 *out_value
+)
+{
+    uacpi_status ret;
+    uacpi_size num_digits;
+    const uacpi_char *digits = *fmt;
+
+    if (!consume_digits(fmt, &num_digits))
+        return mode != PARSE_NUMBER_MODE_MUST;
+
+    ret = uacpi_string_to_integer(digits, num_digits, UACPI_BASE_DEC, out_value);
+    return ret == UACPI_STATUS_OK;
+}
+
+static uacpi_bool consume(const uacpi_char **string, const uacpi_char *token)
+{
+    uacpi_size token_size;
+
+    token_size = uacpi_strlen(token);
+
+    if (!string_has_at_least(*string, token_size))
+        return UACPI_FALSE;
+
+    if (!uacpi_memcmp(*string, token, token_size)) {
+        *string += token_size;
+        return UACPI_TRUE;
+    }
+
+    return UACPI_FALSE;
+}
+
+static uacpi_bool is_one_of(uacpi_char c, const uacpi_char *list)
+{
+    for (; *list; list++) {
+        if (c == *list)
+            return UACPI_TRUE;
+    }
+
+    return UACPI_FALSE;
+}
+
+static uacpi_bool consume_one_of(
+    const uacpi_char **string, const uacpi_char *list, uacpi_char *consumed_char
+)
+{
+    uacpi_char c = **string;
+    if (!c)
+        return UACPI_FALSE;
+
+    if (is_one_of(c, list)) {
+        *consumed_char = c;
+        *string += 1;
+        return UACPI_TRUE;
+    }
+
+    return UACPI_FALSE;
+}
+
+static uacpi_u32 base_from_specifier(uacpi_char specifier)
+{
+    switch (specifier)
+    {
+        case 'x':
+        case 'X':
+            return 16;
+        case 'o':
+            return 8;
+        default:
+            return 10;
+    }
+}
+
+static uacpi_bool is_uppercase_specifier(uacpi_char specifier)
+{
+    return specifier == 'X';
+}
+
+static const uacpi_char *find_next_conversion(
+    const uacpi_char *fmt, uacpi_size *offset
+)
+{
+    *offset = 0;
+
+    while (*fmt) {
+        if (*fmt == '%')
+            return fmt;
+
+        fmt++;
+        *offset += 1;
+    }
+
+    return UACPI_NULL;
+}
+
+uacpi_i32 uacpi_vsnprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,
+    uacpi_va_list vlist
+)
+{
+    struct fmt_buf_state fb_state = {
+        .buffer = buffer,
+        .capacity = capacity,
+        .bytes_written = 0
+    };
+
+    uacpi_u64 value;
+    const uacpi_char *next_conversion;
+    uacpi_size next_offset;
+    uacpi_char flag;
+
+    while (*fmt) {
+        struct fmt_spec fm = {
+            .pad_char = ' ',
+            .base = 10,
+        };
+        next_conversion = find_next_conversion(fmt, &next_offset);
+
+        if (next_offset)
+            write_many(&fb_state, fmt, next_offset);
+
+        if (!next_conversion)
+            break;
+
+        fmt = next_conversion;
+        if (consume(&fmt, "%%")) {
+            write_one(&fb_state, '%');
+            continue;
+        }
+
+        // consume %
+        fmt++;
+
+        while (consume_one_of(&fmt, "+- 0#", &flag)) {
+            switch (flag) {
+            case '+':
+            case ' ':
+                fm.prepend = UACPI_TRUE;
+                fm.prepend_char = flag;
+                continue;
+            case '-':
+                fm.left_justify = UACPI_TRUE;
+                continue;
+            case '0':
+                fm.pad_char = '0';
+                continue;
+            case '#':
+                fm.alternate_form = UACPI_TRUE;
+                continue;
+            default:
+                return -1;
+            }
+        }
+
+        if (consume(&fmt, "*")) {
+            fm.min_width = uacpi_va_arg(vlist, int);
+        } else if (!parse_number(&fmt, PARSE_NUMBER_MODE_MAYBE, &fm.min_width)) {
+            return -1;
+        }
+
+        if (consume(&fmt, ".")) {
+            fm.has_precision = UACPI_TRUE;
+
+            if (consume(&fmt, "*")) {
+                fm.precision = uacpi_va_arg(vlist, int);
+            } else {
+                if (!parse_number(&fmt, PARSE_NUMBER_MODE_MUST, &fm.precision))
+                    return -1;
+            }
+        }
+
+        flag = 0;
+
+        if (consume(&fmt, "c")) {
+            uacpi_char c = uacpi_va_arg(vlist, int);
+            write_one(&fb_state, c);
+            continue;
+        }
+
+        if (consume(&fmt, "s")) {
+            const uacpi_char *string = uacpi_va_arg(vlist, uacpi_char*);
+            uacpi_size i;
+
+            if (uacpi_unlikely(string == UACPI_NULL))
+                string = "<null>";
+
+            for (i = 0; (!fm.has_precision || i < fm.precision) && string[i]; ++i)
+                write_one(&fb_state, string[i]);
+            while (i++ < fm.min_width)
+                write_one(&fb_state, ' ');
+            continue;
+        }
+
+        if (consume(&fmt, "p")) {
+            value = (uacpi_uintptr)uacpi_va_arg(vlist, void*);
+            fm.base = 16;
+            fm.min_width = UACPI_POINTER_SIZE * 2;
+            fm.pad_char = '0';
+            goto write_int;
+        }
+
+        if (consume(&fmt, "hh")) {
+            if (consume(&fmt, "d") || consume(&fmt, "i")) {
+                value = (signed char)uacpi_va_arg(vlist, int);
+                fm.is_signed = UACPI_TRUE;
+            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
+                value = (unsigned char)uacpi_va_arg(vlist, int);
+            } else {
+                return -1;
+            }
+            goto write_int;
+        }
+
+        if (consume(&fmt, "h")) {
+            if (consume(&fmt, "d") || consume(&fmt, "i")) {
+                value = (signed short)uacpi_va_arg(vlist, int);
+                fm.is_signed = UACPI_TRUE;
+            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
+                value = (unsigned short)uacpi_va_arg(vlist, int);
+            } else {
+                return -1;
+            }
+            goto write_int;
+        }
+
+        if (consume(&fmt, "ll") ||
+            (sizeof(uacpi_size) == sizeof(long long) && consume(&fmt, "z"))) {
+            if (consume(&fmt, "d") || consume(&fmt, "i")) {
+                value = uacpi_va_arg(vlist, long long);
+                fm.is_signed = UACPI_TRUE;
+            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
+                value = uacpi_va_arg(vlist, unsigned long long);
+            } else {
+                return -1;
+            }
+            goto write_int;
+        }
+
+        if (consume(&fmt, "l") ||
+            (sizeof(uacpi_size) == sizeof(long) && consume(&fmt, "z"))) {
+            if (consume(&fmt, "d") || consume(&fmt, "i")) {
+                value = uacpi_va_arg(vlist, long);
+                fm.is_signed = UACPI_TRUE;
+            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
+                value = uacpi_va_arg(vlist, unsigned long);
+            } else {
+                return -1;
+            }
+            goto write_int;
+        }
+
+        if (consume(&fmt, "d") || consume(&fmt, "i")) {
+            value = uacpi_va_arg(vlist, uacpi_i32);
+            fm.is_signed = UACPI_TRUE;
+        } else if (consume_one_of(&fmt, "oxXu", &flag)) {
+            value = uacpi_va_arg(vlist, uacpi_u32);
+        } else {
+            return -1;
+        }
+
+    write_int:
+        if (flag != 0) {
+            fm.base = base_from_specifier(flag);
+            fm.uppercase = is_uppercase_specifier(flag);
+        }
+
+        write_integer(&fb_state, &fm, value);
+    }
+
+    if (fb_state.capacity) {
+        uacpi_size last_char;
+
+        last_char = UACPI_MIN(fb_state.bytes_written, fb_state.capacity - 1);
+        fb_state.buffer[last_char] = '\0';
+    }
+
+    return fb_state.bytes_written;
+}
+#endif
+
+#ifndef uacpi_snprintf
+uacpi_i32 uacpi_snprintf(
+    uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, ...
+)
+{
+    uacpi_va_list vlist;
+    uacpi_i32 ret;
+
+    uacpi_va_start(vlist, fmt);
+    ret = uacpi_vsnprintf(buffer, capacity, fmt, vlist);
+    uacpi_va_end(vlist);
+
+    return ret;
+}
+#endif
+
+#ifndef UACPI_FORMATTED_LOGGING
+void uacpi_log(uacpi_log_level lvl, const uacpi_char *str, ...)
+{
+    uacpi_char buf[UACPI_PLAIN_LOG_BUFFER_SIZE];
+    int ret;
+
+    uacpi_va_list vlist;
+    uacpi_va_start(vlist, str);
+
+    ret = uacpi_vsnprintf(buf, sizeof(buf), str, vlist);
+    if (uacpi_unlikely(ret < 0))
+        return;
+
+    /*
+     * If this log message is too large for the configured buffer size, cut off
+     * the end and transform into "...\n" to indicate that it didn't fit and
+     * prevent the newline from being truncated.
+     */
+    if (uacpi_unlikely(ret >= UACPI_PLAIN_LOG_BUFFER_SIZE)) {
+        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 5] = '.';
+        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 4] = '.';
+        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 3] = '.';
+        buf[UACPI_PLAIN_LOG_BUFFER_SIZE - 2] = '\n';
+    }
+
+    uacpi_kernel_log(lvl, buf);
+
+    uacpi_va_end(vlist);
+}
+#endif

drivers/bus/acpi_new/uacpi/source/uacpi.c

@@ -0,0 +1,997 @@
+#include <uacpi/uacpi.h>
+#include <uacpi/acpi.h>
+
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/tables.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/event.h>
+#include <uacpi/internal/notify.h>
+#include <uacpi/internal/osi.h>
+#include <uacpi/internal/registers.h>
+
+struct uacpi_runtime_context g_uacpi_rt_ctx = { 0 };
+
+void uacpi_context_set_log_level(uacpi_log_level lvl)
+{
+    if (lvl == 0)
+        lvl = UACPI_DEFAULT_LOG_LEVEL;
+
+    g_uacpi_rt_ctx.log_level = lvl;
+}
+
+void uacpi_logger_initialize(void)
+{
+    if (g_uacpi_rt_ctx.log_level == 0)
+        uacpi_context_set_log_level(UACPI_DEFAULT_LOG_LEVEL);
+
+    static uacpi_bool version_printed = UACPI_FALSE;
+    if (!version_printed) {
+        version_printed = UACPI_TRUE;
+        uacpi_info(
+            "starting uACPI, version %d.%d.%d\n",
+            UACPI_MAJOR, UACPI_MINOR, UACPI_PATCH
+        );
+    }
+}
+
+void uacpi_context_set_proactive_table_checksum(uacpi_bool setting)
+{
+    if (setting)
+        g_uacpi_rt_ctx.flags |= UACPI_FLAG_PROACTIVE_TBL_CSUM;
+    else
+        g_uacpi_rt_ctx.flags &= ~UACPI_FLAG_PROACTIVE_TBL_CSUM;
+}
+
+const uacpi_char *uacpi_status_to_string(uacpi_status st)
+{
+    switch (st) {
+    case UACPI_STATUS_OK:
+        return "no error";
+    case UACPI_STATUS_MAPPING_FAILED:
+        return "failed to map memory";
+    case UACPI_STATUS_OUT_OF_MEMORY:
+        return "out of memory";
+    case UACPI_STATUS_BAD_CHECKSUM:
+        return "bad table checksum";
+    case UACPI_STATUS_INVALID_SIGNATURE:
+        return "invalid table signature";
+    case UACPI_STATUS_INVALID_TABLE_LENGTH:
+        return "invalid table length";
+    case UACPI_STATUS_NOT_FOUND:
+        return "not found";
+    case UACPI_STATUS_INVALID_ARGUMENT:
+        return "invalid argument";
+    case UACPI_STATUS_UNIMPLEMENTED:
+        return "unimplemented";
+    case UACPI_STATUS_ALREADY_EXISTS:
+        return "already exists";
+    case UACPI_STATUS_INTERNAL_ERROR:
+        return "internal error";
+    case UACPI_STATUS_TYPE_MISMATCH:
+        return "object type mismatch";
+    case UACPI_STATUS_INIT_LEVEL_MISMATCH:
+        return "init level too low/high for this action";
+    case UACPI_STATUS_NAMESPACE_NODE_DANGLING:
+        return "attempting to use a dangling namespace node";
+    case UACPI_STATUS_NO_HANDLER:
+        return "no handler found";
+    case UACPI_STATUS_NO_RESOURCE_END_TAG:
+        return "resource template without an end tag";
+    case UACPI_STATUS_COMPILED_OUT:
+        return "this functionality has been compiled out of this build";
+    case UACPI_STATUS_HARDWARE_TIMEOUT:
+        return "timed out waiting for hardware response";
+    case UACPI_STATUS_TIMEOUT:
+        return "wait timed out";
+    case UACPI_STATUS_OVERRIDDEN:
+        return "the requested action has been overridden";
+    case UACPI_STATUS_DENIED:
+        return "the requested action has been denied";
+
+    case UACPI_STATUS_AML_UNDEFINED_REFERENCE:
+        return "AML referenced an undefined object";
+    case UACPI_STATUS_AML_INVALID_NAMESTRING:
+        return "invalid AML name string";
+    case UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS:
+        return "object already exists";
+    case UACPI_STATUS_AML_INVALID_OPCODE:
+        return "invalid AML opcode";
+    case UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE:
+        return "incompatible AML object type";
+    case UACPI_STATUS_AML_BAD_ENCODING:
+        return "bad AML instruction encoding";
+    case UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX:
+        return "out of bounds AML index";
+    case UACPI_STATUS_AML_SYNC_LEVEL_TOO_HIGH:
+        return "AML attempted to acquire a mutex with a lower sync level";
+    case UACPI_STATUS_AML_INVALID_RESOURCE:
+        return "invalid resource template encoding or type";
+    case UACPI_STATUS_AML_LOOP_TIMEOUT:
+        return "hanging AML while loop";
+    case UACPI_STATUS_AML_CALL_STACK_DEPTH_LIMIT:
+        return "reached maximum AML call stack depth";
+    default:
+        return "<invalid status>";
+    }
+}
+
+void uacpi_state_reset(void)
+{
+#ifndef UACPI_BAREBONES_MODE
+    uacpi_deinitialize_namespace();
+    uacpi_deinitialize_interfaces();
+    uacpi_deinitialize_events();
+    uacpi_deinitialize_notify();
+    uacpi_deinitialize_opregion();
+#endif
+
+    uacpi_deinitialize_tables();
+
+#ifndef UACPI_BAREBONES_MODE
+
+#ifndef UACPI_REDUCED_HARDWARE
+    if (g_uacpi_rt_ctx.was_in_legacy_mode)
+        uacpi_leave_acpi_mode();
+#endif
+
+    uacpi_deinitialize_registers();
+
+#ifndef UACPI_REDUCED_HARDWARE
+    if (g_uacpi_rt_ctx.global_lock_event)
+        uacpi_kernel_free_event(g_uacpi_rt_ctx.global_lock_event);
+    if (g_uacpi_rt_ctx.global_lock_spinlock)
+        uacpi_kernel_free_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+#endif
+
+#endif // !UACPI_BAREBONES_MODE
+
+    uacpi_memzero(&g_uacpi_rt_ctx, sizeof(g_uacpi_rt_ctx));
+
+#if defined(UACPI_KERNEL_INITIALIZATION) && !defined(UACPI_BAREBONES_MODE)
+    uacpi_kernel_deinitialize();
+#endif
+}
+
+#ifndef UACPI_BAREBONES_MODE
+
+void uacpi_context_set_loop_timeout(uacpi_u32 seconds)
+{
+    if (seconds == 0)
+        seconds = UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS;
+
+    g_uacpi_rt_ctx.loop_timeout_seconds = seconds;
+}
+
+void uacpi_context_set_max_call_stack_depth(uacpi_u32 depth)
+{
+    if (depth == 0)
+        depth = UACPI_DEFAULT_MAX_CALL_STACK_DEPTH;
+
+    g_uacpi_rt_ctx.max_call_stack_depth = depth;
+}
+
+uacpi_u32 uacpi_context_get_loop_timeout(void)
+{
+    return g_uacpi_rt_ctx.loop_timeout_seconds;
+}
+
+#ifndef UACPI_REDUCED_HARDWARE
+enum hw_mode {
+    HW_MODE_ACPI = 0,
+    HW_MODE_LEGACY = 1,
+};
+
+static enum hw_mode read_mode(void)
+{
+    uacpi_status ret;
+    uacpi_u64 raw_value;
+    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+
+    if (!fadt->smi_cmd)
+        return HW_MODE_ACPI;
+
+    ret = uacpi_read_register_field(UACPI_REGISTER_FIELD_SCI_EN, &raw_value);
+    if (uacpi_unlikely_error(ret))
+        return HW_MODE_LEGACY;
+
+    return raw_value ? HW_MODE_ACPI : HW_MODE_LEGACY;
+}
+
+static uacpi_status set_mode(enum hw_mode mode)
+{
+    uacpi_status ret;
+    uacpi_u64 raw_value, stalled_time = 0;
+    struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+
+    if (uacpi_unlikely(!fadt->smi_cmd)) {
+        uacpi_error("SMI_CMD is not implemented by the firmware\n");
+        return UACPI_STATUS_NOT_FOUND;
+    }
+
+    if (uacpi_unlikely(!fadt->acpi_enable && !fadt->acpi_disable)) {
+        uacpi_error("mode transition is not implemented by the hardware\n");
+        return UACPI_STATUS_NOT_FOUND;
+    }
+
+    switch (mode) {
+    case HW_MODE_ACPI:
+        raw_value = fadt->acpi_enable;
+        break;
+    case HW_MODE_LEGACY:
+        raw_value = fadt->acpi_disable;
+        break;
+    default:
+        return UACPI_STATUS_INVALID_ARGUMENT;
+    }
+
+    ret = uacpi_write_register(UACPI_REGISTER_SMI_CMD, raw_value);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    // Allow up to 5 seconds for the hardware to enter the desired mode
+    while (stalled_time < (5 * 1000 * 1000)) {
+        if (read_mode() == mode)
+            return UACPI_STATUS_OK;
+
+        uacpi_kernel_stall(100);
+        stalled_time += 100;
+    }
+
+    uacpi_error("hardware time out while changing modes\n");
+    return UACPI_STATUS_HARDWARE_TIMEOUT;
+}
+
+static uacpi_status enter_mode(enum hw_mode mode, uacpi_bool *did_change)
+{
+    uacpi_status ret;
+    const uacpi_char *mode_str;
+
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    if (uacpi_is_hardware_reduced())
+        return UACPI_STATUS_OK;
+
+    mode_str = mode == HW_MODE_LEGACY ? "legacy" : "acpi";
+
+    if (read_mode() == mode) {
+        uacpi_trace("%s mode already enabled\n", mode_str);
+        return UACPI_STATUS_OK;
+    }
+
+    ret = set_mode(mode);
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_warn(
+            "unable to enter %s mode: %s\n",
+            mode_str, uacpi_status_to_string(ret)
+        );
+        return ret;
+    }
+
+    uacpi_trace("entered %s mode\n", mode_str);
+    if (did_change != UACPI_NULL)
+        *did_change = UACPI_TRUE;
+
+    return ret;
+}
+
+uacpi_status uacpi_enter_acpi_mode(void)
+{
+    return enter_mode(HW_MODE_ACPI, UACPI_NULL);
+}
+
+uacpi_status uacpi_leave_acpi_mode(void)
+{
+    return enter_mode(HW_MODE_LEGACY, UACPI_NULL);
+}
+
+static void enter_acpi_mode_initial(void)
+{
+    enter_mode(HW_MODE_ACPI, &g_uacpi_rt_ctx.was_in_legacy_mode);
+}
+#else
+static void enter_acpi_mode_initial(void) { }
+#endif
+
+uacpi_init_level uacpi_get_current_init_level(void)
+{
+    return g_uacpi_rt_ctx.init_level;
+}
+
+uacpi_status uacpi_initialize(uacpi_u64 flags)
+{
+    uacpi_status ret;
+
+    UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_EARLY);
+
+#ifdef UACPI_KERNEL_INITIALIZATION
+    ret = uacpi_kernel_initialize(UACPI_INIT_LEVEL_EARLY);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+#endif
+
+    g_uacpi_rt_ctx.init_level = UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED;
+    g_uacpi_rt_ctx.last_sleep_typ_a = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.last_sleep_typ_b = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.s0_sleep_typ_a = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.s0_sleep_typ_b = UACPI_SLEEP_TYP_INVALID;
+    g_uacpi_rt_ctx.flags = flags;
+
+    uacpi_logger_initialize();
+
+    if (g_uacpi_rt_ctx.loop_timeout_seconds == 0)
+        uacpi_context_set_loop_timeout(UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS);
+    if (g_uacpi_rt_ctx.max_call_stack_depth == 0)
+        uacpi_context_set_max_call_stack_depth(UACPI_DEFAULT_MAX_CALL_STACK_DEPTH);
+
+    ret = uacpi_initialize_tables();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_registers();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_events_early();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_opregion();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_interfaces();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_namespace();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    ret = uacpi_initialize_notify();
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+
+    uacpi_install_default_address_space_handlers();
+
+    if (!uacpi_check_flag(UACPI_FLAG_NO_ACPI_MODE))
+        enter_acpi_mode_initial();
+
+    return UACPI_STATUS_OK;
+
+out_fatal_error:
+    uacpi_state_reset();
+    return ret;
+}
+
+struct table_load_stats {
+    uacpi_u32 load_counter;
+    uacpi_u32 failure_counter;
+};
+
+static void trace_table_load_failure(
+    struct acpi_sdt_hdr *tbl, uacpi_log_level lvl, uacpi_status ret
+)
+{
+    uacpi_log_lvl(
+        lvl,
+        "failed to load "UACPI_PRI_TBL_HDR": %s\n",
+        UACPI_FMT_TBL_HDR(tbl), uacpi_status_to_string(ret)
+    );
+}
+
+static uacpi_bool match_ssdt_or_psdt(struct uacpi_installed_table *tbl)
+{
+    if (tbl->flags & UACPI_TABLE_LOADED)
+        return UACPI_FALSE;
+
+    return uacpi_signatures_match(tbl->hdr.signature, ACPI_SSDT_SIGNATURE) ||
+           uacpi_signatures_match(tbl->hdr.signature, ACPI_PSDT_SIGNATURE);
+}
+
+static uacpi_u64 elapsed_ms(uacpi_u64 begin_ns, uacpi_u64 end_ns)
+{
+    return (end_ns - begin_ns) / (1000ull * 1000ull);
+}
+
+static uacpi_bool warn_on_bad_timesource(uacpi_u64 begin_ts, uacpi_u64 end_ts)
+{
+    const uacpi_char *reason;
+
+    if (uacpi_unlikely(begin_ts == 0 && end_ts == 0)) {
+        reason = "uacpi_kernel_get_nanoseconds_since_boot() appears to be a stub";
+        goto out_bad_timesource;
+    }
+
+    if (uacpi_unlikely(begin_ts == end_ts)) {
+        reason = "poor time source precision detected";
+        goto out_bad_timesource;
+    }
+
+    if (uacpi_unlikely(end_ts < begin_ts)) {
+        reason = "time source backwards drift detected";
+        goto out_bad_timesource;
+    }
+
+    return UACPI_FALSE;
+
+out_bad_timesource:
+    uacpi_warn("%s, this may cause problems\n", reason);
+    return UACPI_TRUE;
+}
+
+uacpi_status uacpi_namespace_load(void)
+{
+    struct uacpi_table tbl;
+    uacpi_status ret;
+    uacpi_u64 begin_ts, end_ts;
+    struct table_load_stats st = { 0 };
+    uacpi_size cur_index;
+
+    UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+#ifdef UACPI_KERNEL_INITIALIZATION
+    ret = uacpi_kernel_initialize(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+    if (uacpi_unlikely_error(ret))
+        goto out_fatal_error;
+#endif
+
+    begin_ts = uacpi_kernel_get_nanoseconds_since_boot();
+
+    ret = uacpi_table_find_by_signature(ACPI_DSDT_SIGNATURE, &tbl);
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_error("unable to find DSDT: %s\n", uacpi_status_to_string(ret));
+        goto out_fatal_error;
+    }
+
+    ret = uacpi_table_load_with_cause(tbl.index, UACPI_TABLE_LOAD_CAUSE_INIT);
+    if (uacpi_unlikely_error(ret)) {
+        trace_table_load_failure(tbl.hdr, UACPI_LOG_ERROR, ret);
+        st.failure_counter++;
+    }
+    st.load_counter++;
+    uacpi_table_unref(&tbl);
+
+    for (cur_index = 0;; cur_index = tbl.index + 1) {
+        ret = uacpi_table_match(cur_index, match_ssdt_or_psdt, &tbl);
+        if (ret != UACPI_STATUS_OK) {
+            if (uacpi_unlikely(ret != UACPI_STATUS_NOT_FOUND))
+                goto out_fatal_error;
+
+            break;
+        }
+
+        ret = uacpi_table_load_with_cause(tbl.index, UACPI_TABLE_LOAD_CAUSE_INIT);
+        if (uacpi_unlikely_error(ret)) {
+            trace_table_load_failure(tbl.hdr, UACPI_LOG_WARN, ret);
+            st.failure_counter++;
+        }
+        st.load_counter++;
+        uacpi_table_unref(&tbl);
+    }
+
+    end_ts = uacpi_kernel_get_nanoseconds_since_boot();
+    g_uacpi_rt_ctx.bad_timesource = warn_on_bad_timesource(begin_ts, end_ts);
+
+    if (uacpi_unlikely(st.failure_counter != 0 || g_uacpi_rt_ctx.bad_timesource)) {
+        uacpi_info(
+            "loaded %u AML blob%s (%u error%s)\n",
+            st.load_counter, st.load_counter > 1 ? "s" : "", st.failure_counter,
+            st.failure_counter == 1 ? "" : "s"
+        );
+    } else {
+        uacpi_u64 ops = g_uacpi_rt_ctx.opcodes_executed;
+        uacpi_u64 ops_per_sec = ops * UACPI_NANOSECONDS_PER_SEC;
+
+        ops_per_sec /= end_ts - begin_ts;
+
+        uacpi_info(
+            "successfully loaded %u AML blob%s, %"UACPI_PRIu64" ops in "
+            "%"UACPI_PRIu64"ms (avg %"UACPI_PRIu64"/s)\n",
+            st.load_counter, st.load_counter > 1 ? "s" : "",
+            UACPI_FMT64(ops), UACPI_FMT64(elapsed_ms(begin_ts, end_ts)),
+            UACPI_FMT64(ops_per_sec)
+        );
+    }
+
+    ret = uacpi_initialize_events();
+    if (uacpi_unlikely_error(ret)) {
+        uacpi_error("event initialization failed: %s\n",
+                    uacpi_status_to_string(ret));
+        goto out_fatal_error;
+    }
+
+    g_uacpi_rt_ctx.init_level = UACPI_INIT_LEVEL_NAMESPACE_LOADED;
+    return UACPI_STATUS_OK;
+
+out_fatal_error:
+    uacpi_state_reset();
+    return ret;
+}
+
+struct ns_init_context {
+    uacpi_size ini_executed;
+    uacpi_size ini_errors;
+    uacpi_size sta_executed;
+    uacpi_size sta_errors;
+    uacpi_size devices;
+    uacpi_size thermal_zones;
+};
+
+static void ini_eval(struct ns_init_context *ctx, uacpi_namespace_node *node)
+{
+    uacpi_status ret;
+
+    ret = uacpi_eval(node, "_INI", UACPI_NULL, UACPI_NULL);
+    if (ret == UACPI_STATUS_NOT_FOUND)
+        return;
+
+    ctx->ini_executed++;
+    if (uacpi_unlikely_error(ret))
+        ctx->ini_errors++;
+}
+
+static uacpi_status sta_eval(
+    struct ns_init_context *ctx, uacpi_namespace_node *node,
+    uacpi_u32 *value
+)
+{
+    uacpi_status ret;
+
+    ret = uacpi_eval_sta(node, value);
+    if (*value == 0xFFFFFFFF)
+        return ret;
+
+    ctx->sta_executed++;
+    if (uacpi_unlikely_error(ret))
+        ctx->sta_errors++;
+
+    return ret;
+}
+
+static uacpi_iteration_decision do_sta_ini(
+    void *opaque, uacpi_namespace_node *node, uacpi_u32 depth
+)
+{
+    struct ns_init_context *ctx = opaque;
+    uacpi_status ret;
+    uacpi_object_type type = UACPI_OBJECT_UNINITIALIZED;
+    uacpi_u32 sta_ret;
+
+    UACPI_UNUSED(depth);
+
+    // We don't care about aliases
+    if (uacpi_namespace_node_is_alias(node))
+        return UACPI_ITERATION_DECISION_NEXT_PEER;
+
+    ret = uacpi_namespace_node_type(node, &type);
+    switch (type) {
+    case UACPI_OBJECT_DEVICE:
+    case UACPI_OBJECT_PROCESSOR:
+        ctx->devices++;
+        break;
+    case UACPI_OBJECT_THERMAL_ZONE:
+        ctx->thermal_zones++;
+        break;
+    default:
+        if (node != uacpi_namespace_get_predefined(UACPI_PREDEFINED_NAMESPACE_TZ))
+            return UACPI_ITERATION_DECISION_CONTINUE;
+    }
+
+    ret = sta_eval(ctx, node, &sta_ret);
+    if (uacpi_unlikely_error(ret))
+        return UACPI_ITERATION_DECISION_CONTINUE;
+
+    if (!(sta_ret & ACPI_STA_RESULT_DEVICE_PRESENT)) {
+        if (!(sta_ret & ACPI_STA_RESULT_DEVICE_FUNCTIONING))
+            return UACPI_ITERATION_DECISION_NEXT_PEER;
+
+        /*
+         * ACPI 6.5 specification:
+         * _STA may return bit 0 clear (not present) with bit [3] set (device
+         * is functional). This case is used to indicate a valid device for
+         * which no device driver should be loaded (for example, a bridge
+         * device.) Children of this device may be present and valid. OSPM
+         * should continue enumeration below a device whose _STA returns this
+         * bit combination.
+         */
+        return UACPI_ITERATION_DECISION_CONTINUE;
+    }
+
+    ini_eval(ctx, node);
+
+    return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+uacpi_status uacpi_namespace_initialize(void)
+{
+    struct ns_init_context ctx = { 0 };
+    uacpi_namespace_node *root;
+    uacpi_u64 begin_ts, end_ts;
+    uacpi_address_space_handlers *handlers;
+    uacpi_address_space_handler *handler;
+    uacpi_status ret = UACPI_STATUS_OK;
+
+    UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+#ifdef UACPI_KERNEL_INITIALIZATION
+    ret = uacpi_kernel_initialize(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+    if (uacpi_unlikely_error(ret))
+        goto out;
+#endif
+
+    /*
+     * Initialization order here is identical to ACPICA because ACPI
+     * specification doesn't really have any detailed steps that explain
+     * how to do it.
+     */
+
+    root = uacpi_namespace_root();
+
+    begin_ts = uacpi_kernel_get_nanoseconds_since_boot();
+
+    // Step 1 - Execute \_INI
+    ini_eval(&ctx, root);
+
+    // Step 2 - Execute \_SB._INI
+    ini_eval(
+        &ctx, uacpi_namespace_get_predefined(UACPI_PREDEFINED_NAMESPACE_SB)
+    );
+
+    /*
+     * Step 3 - Run _REG methods for all globally installed
+     *          address space handlers.
+     */
+    handlers = uacpi_node_get_address_space_handlers(root);
+    if (handlers) {
+        handler = handlers->head;
+
+        while (handler) {
+            if (uacpi_address_space_handler_is_default(handler))
+                uacpi_reg_all_opregions(root, handler->space);
+
+            handler = handler->next;
+        }
+    }
+
+    // Step 4 - Run all other _STA and _INI methods
+    uacpi_namespace_for_each_child(
+        root, do_sta_ini, UACPI_NULL,
+        UACPI_OBJECT_ANY_BIT, UACPI_MAX_DEPTH_ANY, &ctx
+    );
+
+    end_ts = uacpi_kernel_get_nanoseconds_since_boot();
+
+    if (uacpi_likely(!g_uacpi_rt_ctx.bad_timesource)) {
+        uacpi_info(
+            "namespace initialization done in %"UACPI_PRIu64"ms: "
+            "%zu devices, %zu thermal zones\n",
+            UACPI_FMT64(elapsed_ms(begin_ts, end_ts)),
+            ctx.devices, ctx.thermal_zones
+        );
+    } else {
+        uacpi_info(
+            "namespace initialization done: %zu devices, %zu thermal zones\n",
+            ctx.devices, ctx.thermal_zones
+        );
+    }
+
+    uacpi_trace(
+        "_STA calls: %zu (%zu errors), _INI calls: %zu (%zu errors)\n",
+        ctx.sta_executed, ctx.sta_errors, ctx.ini_executed,
+        ctx.ini_errors
+    );
+
+    g_uacpi_rt_ctx.init_level = UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED;
+#ifdef UACPI_KERNEL_INITIALIZATION
+    ret = uacpi_kernel_initialize(UACPI_INIT_LEVEL_NAMESPACE_INITIALIZED);
+out:
+    if (uacpi_unlikely_error(ret))
+        uacpi_state_reset();
+#endif
+    return ret;
+}
+
+uacpi_status uacpi_eval(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **out_obj
+)
+{
+    struct uacpi_namespace_node *node;
+    uacpi_control_method *method;
+    uacpi_object *obj;
+    uacpi_status ret = UACPI_STATUS_INVALID_ARGUMENT;
+
+    if (uacpi_unlikely(parent == UACPI_NULL && path == UACPI_NULL))
+        return ret;
+
+    ret = uacpi_namespace_read_lock();
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (path != UACPI_NULL) {
+        ret = uacpi_namespace_node_resolve(
+            parent, path, UACPI_SHOULD_LOCK_NO,
+            UACPI_MAY_SEARCH_ABOVE_PARENT_NO, UACPI_PERMANENT_ONLY_YES,
+            &node
+        );
+        if (uacpi_unlikely_error(ret))
+            goto out_read_unlock;
+    } else {
+        node = parent;
+    }
+
+    obj = uacpi_namespace_node_get_object(node);
+    if (uacpi_unlikely(obj == UACPI_NULL)) {
+        ret = UACPI_STATUS_INVALID_ARGUMENT;
+        goto out_read_unlock;
+    }
+
+    if (obj->type != UACPI_OBJECT_METHOD) {
+        uacpi_object *new_obj;
+
+        if (uacpi_unlikely(out_obj == UACPI_NULL))
+            goto out_read_unlock;
+
+        new_obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+        if (uacpi_unlikely(new_obj == UACPI_NULL)) {
+            ret = UACPI_STATUS_OUT_OF_MEMORY;
+            goto out_read_unlock;
+        }
+
+        ret = uacpi_object_assign(
+            new_obj, obj, UACPI_ASSIGN_BEHAVIOR_DEEP_COPY
+        );
+        if (uacpi_unlikely_error(ret)) {
+            uacpi_object_unref(new_obj);
+            goto out_read_unlock;
+        }
+        *out_obj = new_obj;
+
+    out_read_unlock:
+        uacpi_namespace_read_unlock();
+        return ret;
+    }
+
+    method = obj->method;
+    uacpi_shareable_ref(method);
+    uacpi_namespace_read_unlock();
+
+    // Upgrade to a write-lock since we're about to run a method
+    ret = uacpi_namespace_write_lock();
+    if (uacpi_unlikely_error(ret))
+        goto out_no_write_lock;
+
+    ret = uacpi_execute_control_method(node, method, args, out_obj);
+    uacpi_namespace_write_unlock();
+
+out_no_write_lock:
+    uacpi_method_unref(method);
+    return ret;
+}
+
+uacpi_status uacpi_eval_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+)
+{
+    return uacpi_eval(parent, path, UACPI_NULL, ret);
+}
+
+uacpi_status uacpi_execute(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args
+)
+{
+    return uacpi_eval(parent, path, args, UACPI_NULL);
+}
+
+uacpi_status uacpi_execute_simple(
+    uacpi_namespace_node *parent, const uacpi_char *path
+)
+{
+    return uacpi_eval(parent, path, UACPI_NULL, UACPI_NULL);
+}
+
+#define TRACE_BAD_RET(path_fmt, type, ...)                                 \
+    uacpi_warn(                                                            \
+        "unexpected '%s' object returned by method "path_fmt               \
+        ", expected type mask: %08X\n", uacpi_object_type_to_string(type), \
+        __VA_ARGS__                                                        \
+    )
+
+#define TRACE_NO_RET(path_fmt, ...)                                        \
+    uacpi_warn(                                                            \
+        "no value returned from method "path_fmt", expected type mask: "   \
+        "%08X\n", __VA_ARGS__                                              \
+    )
+
+static void trace_invalid_return_type(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    uacpi_object_type_bits expected_mask, uacpi_object_type actual_type
+)
+{
+    const uacpi_char *abs_path;
+    uacpi_bool dynamic_abs_path = UACPI_FALSE;
+
+    if (parent == UACPI_NULL || (path != UACPI_NULL && path[0] == '\\')) {
+        abs_path = path;
+    } else {
+        abs_path = uacpi_namespace_node_generate_absolute_path(parent);
+        dynamic_abs_path = UACPI_TRUE;
+    }
+
+    if (dynamic_abs_path && path != UACPI_NULL) {
+        if (actual_type == UACPI_OBJECT_UNINITIALIZED)
+            TRACE_NO_RET("%s.%s", abs_path, path, expected_mask);
+        else
+            TRACE_BAD_RET("%s.%s", actual_type, abs_path, path, expected_mask);
+    } else {
+        if (actual_type == UACPI_OBJECT_UNINITIALIZED) {
+            TRACE_NO_RET("%s", abs_path, expected_mask);
+        } else {
+            TRACE_BAD_RET("%s", actual_type, abs_path, expected_mask);
+        }
+    }
+
+    if (dynamic_abs_path)
+        uacpi_free_dynamic_string(abs_path);
+}
+
+uacpi_status uacpi_eval_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object_type_bits ret_mask,
+    uacpi_object **out_obj
+)
+{
+    uacpi_status ret;
+    uacpi_object *obj;
+    uacpi_object_type returned_type = UACPI_OBJECT_UNINITIALIZED;
+
+    if (uacpi_unlikely(out_obj == UACPI_NULL))
+        return UACPI_STATUS_INVALID_ARGUMENT;
+
+    ret = uacpi_eval(parent, path, args, &obj);
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    if (obj != UACPI_NULL)
+        returned_type = obj->type;
+
+    if (ret_mask && (ret_mask & (1 << returned_type)) == 0) {
+        trace_invalid_return_type(parent, path, ret_mask, returned_type);
+        uacpi_object_unref(obj);
+        return UACPI_STATUS_TYPE_MISMATCH;
+    }
+
+    *out_obj = obj;
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_eval_simple_typed(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    uacpi_object_type_bits ret_mask, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(parent, path, UACPI_NULL, ret_mask, ret);
+}
+
+uacpi_status uacpi_eval_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_u64 *out_value
+)
+{
+    uacpi_object *int_obj;
+    uacpi_status ret;
+
+    ret = uacpi_eval_typed(
+        parent, path, args, UACPI_OBJECT_INTEGER_BIT, &int_obj
+    );
+    if (uacpi_unlikely_error(ret))
+        return ret;
+
+    *out_value = int_obj->integer;
+    uacpi_object_unref(int_obj);
+
+    return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_eval_simple_integer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_u64 *out_value
+)
+{
+    return uacpi_eval_integer(parent, path, UACPI_NULL, out_value);
+}
+
+uacpi_status uacpi_eval_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, args,
+        UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT,
+        ret
+    );
+}
+
+uacpi_status uacpi_eval_simple_buffer_or_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, UACPI_NULL,
+        UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT,
+        ret
+    );
+}
+
+uacpi_status uacpi_eval_string(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, args, UACPI_OBJECT_STRING_BIT, ret
+    );
+}
+
+uacpi_status uacpi_eval_simple_string(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, UACPI_NULL, UACPI_OBJECT_STRING_BIT, ret
+    );
+}
+
+uacpi_status uacpi_eval_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, args, UACPI_OBJECT_BUFFER_BIT, ret
+    );
+}
+
+uacpi_status uacpi_eval_simple_buffer(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, UACPI_NULL, UACPI_OBJECT_BUFFER_BIT, ret
+    );
+}
+
+uacpi_status uacpi_eval_package(
+    uacpi_namespace_node *parent, const uacpi_char *path,
+    const uacpi_object_array *args, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, args, UACPI_OBJECT_PACKAGE_BIT, ret
+    );
+}
+
+uacpi_status uacpi_eval_simple_package(
+    uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret
+)
+{
+    return uacpi_eval_typed(
+        parent, path, UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, ret
+    );
+}
+
+uacpi_status uacpi_get_aml_bitness(uacpi_u8 *out_bitness)
+{
+    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+    *out_bitness = g_uacpi_rt_ctx.is_rev1 ? 32 : 64;
+    return UACPI_STATUS_OK;
+}
+
+#endif // !UACPI_BAREBONES_MODE