summaryrefslogtreecommitdiff
path: root/sys/dev/acpi/uacpi
diff options
context:
space:
mode:
Diffstat (limited to 'sys/dev/acpi/uacpi')
-rw-r--r--sys/dev/acpi/uacpi/default_handlers.c336
-rw-r--r--sys/dev/acpi/uacpi/event.c2449
-rw-r--r--sys/dev/acpi/uacpi/interpreter.c6053
-rw-r--r--sys/dev/acpi/uacpi/io.c1116
-rw-r--r--sys/dev/acpi/uacpi/mutex.c396
-rw-r--r--sys/dev/acpi/uacpi/namespace.c1081
-rw-r--r--sys/dev/acpi/uacpi/notify.c255
-rw-r--r--sys/dev/acpi/uacpi/opcodes.c272
-rw-r--r--sys/dev/acpi/uacpi/opregion.c1056
-rw-r--r--sys/dev/acpi/uacpi/osi.c388
-rw-r--r--sys/dev/acpi/uacpi/registers.c572
-rw-r--r--sys/dev/acpi/uacpi/resources.c2569
-rw-r--r--sys/dev/acpi/uacpi/shareable.c71
-rw-r--r--sys/dev/acpi/uacpi/sleep.c616
-rw-r--r--sys/dev/acpi/uacpi/stdlib.c728
-rw-r--r--sys/dev/acpi/uacpi/tables.c1399
-rw-r--r--sys/dev/acpi/uacpi/types.c1489
-rw-r--r--sys/dev/acpi/uacpi/uacpi.c998
-rw-r--r--sys/dev/acpi/uacpi/utilities.c1156
19 files changed, 23000 insertions, 0 deletions
diff --git a/sys/dev/acpi/uacpi/default_handlers.c b/sys/dev/acpi/uacpi/default_handlers.c
new file mode 100644
index 0000000..32259d6
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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
diff --git a/sys/dev/acpi/uacpi/event.c b/sys/dev/acpi/uacpi/event.c
new file mode 100644
index 0000000..0c58372
--- /dev/null
+++ b/sys/dev/acpi/uacpi/event.c
@@ -0,0 +1,2449 @@
+#include <uacpi/internal/event.h>
+#include <uacpi/internal/registers.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/notify.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/acpi.h>
+
+#define UACPI_EVENT_DISABLED 0
+#define UACPI_EVENT_ENABLED 1
+
+#if !defined(UACPI_REDUCED_HARDWARE) && !defined(UACPI_BAREBONES_MODE)
+
+static uacpi_handle g_gpe_state_slock;
+static struct uacpi_recursive_lock g_event_lock;
+static uacpi_bool g_gpes_finalized;
+
+struct fixed_event {
+ uacpi_u8 enable_field;
+ uacpi_u8 status_field;
+ uacpi_u16 enable_mask;
+ uacpi_u16 status_mask;
+};
+
+struct fixed_event_handler {
+ uacpi_interrupt_handler handler;
+ uacpi_handle ctx;
+};
+
+static const struct fixed_event fixed_events[UACPI_FIXED_EVENT_MAX + 1] = {
+ [UACPI_FIXED_EVENT_GLOBAL_LOCK] = {
+ .status_field = UACPI_REGISTER_FIELD_GBL_STS,
+ .enable_field = UACPI_REGISTER_FIELD_GBL_EN,
+ .enable_mask = ACPI_PM1_EN_GBL_EN_MASK,
+ .status_mask = ACPI_PM1_STS_GBL_STS_MASK,
+ },
+ [UACPI_FIXED_EVENT_TIMER_STATUS] = {
+ .status_field = UACPI_REGISTER_FIELD_TMR_STS,
+ .enable_field = UACPI_REGISTER_FIELD_TMR_EN,
+ .enable_mask = ACPI_PM1_EN_TMR_EN_MASK,
+ .status_mask = ACPI_PM1_STS_TMR_STS_MASK,
+ },
+ [UACPI_FIXED_EVENT_POWER_BUTTON] = {
+ .status_field = UACPI_REGISTER_FIELD_PWRBTN_STS,
+ .enable_field = UACPI_REGISTER_FIELD_PWRBTN_EN,
+ .enable_mask = ACPI_PM1_EN_PWRBTN_EN_MASK,
+ .status_mask = ACPI_PM1_STS_PWRBTN_STS_MASK,
+ },
+ [UACPI_FIXED_EVENT_SLEEP_BUTTON] = {
+ .status_field = UACPI_REGISTER_FIELD_SLPBTN_STS,
+ .enable_field = UACPI_REGISTER_FIELD_SLPBTN_EN,
+ .enable_mask = ACPI_PM1_EN_SLPBTN_EN_MASK,
+ .status_mask = ACPI_PM1_STS_SLPBTN_STS_MASK,
+ },
+ [UACPI_FIXED_EVENT_RTC] = {
+ .status_field = UACPI_REGISTER_FIELD_RTC_STS,
+ .enable_field = UACPI_REGISTER_FIELD_RTC_EN,
+ .enable_mask = ACPI_PM1_EN_RTC_EN_MASK,
+ .status_mask = ACPI_PM1_STS_RTC_STS_MASK,
+ },
+};
+
+static struct fixed_event_handler
+fixed_event_handlers[UACPI_FIXED_EVENT_MAX + 1];
+
+static uacpi_status initialize_fixed_events(void)
+{
+ uacpi_size i;
+
+ for (i = 0; i < UACPI_FIXED_EVENT_MAX; ++i) {
+ uacpi_write_register_field(
+ fixed_events[i].enable_field, UACPI_EVENT_DISABLED
+ );
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status set_event(uacpi_u8 event, uacpi_u8 value)
+{
+ uacpi_status ret;
+ uacpi_u64 raw_value;
+ const struct fixed_event *ev = &fixed_events[event];
+
+ ret = uacpi_write_register_field(ev->enable_field, value);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_read_register_field(ev->enable_field, &raw_value);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (raw_value != value) {
+ uacpi_error("failed to %sable fixed event %d\n",
+ value ? "en" : "dis", event);
+ return UACPI_STATUS_HARDWARE_TIMEOUT;
+ }
+
+ uacpi_trace("fixed event %d %sabled successfully\n",
+ event, value ? "en" : "dis");
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_enable_fixed_event(uacpi_fixed_event event)
+{
+ uacpi_status ret;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ /*
+ * Attempting to enable an event that doesn't have a handler is most likely
+ * an error, don't allow it.
+ */
+ if (uacpi_unlikely(fixed_event_handlers[event].handler == UACPI_NULL)) {
+ ret = UACPI_STATUS_NO_HANDLER;
+ goto out;
+ }
+
+ ret = set_event(event, UACPI_EVENT_ENABLED);
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_disable_fixed_event(uacpi_fixed_event event)
+{
+ uacpi_status ret;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = set_event(event, UACPI_EVENT_DISABLED);
+
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_clear_fixed_event(uacpi_fixed_event event)
+{
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ return uacpi_write_register_field(
+ fixed_events[event].status_field, ACPI_PM1_STS_CLEAR
+ );
+}
+
+static uacpi_interrupt_ret dispatch_fixed_event(
+ const struct fixed_event *ev, uacpi_fixed_event event
+)
+{
+ uacpi_status ret;
+ struct fixed_event_handler *evh = &fixed_event_handlers[event];
+
+ ret = uacpi_write_register_field(ev->status_field, ACPI_PM1_STS_CLEAR);
+ if (uacpi_unlikely_error(ret))
+ return UACPI_INTERRUPT_NOT_HANDLED;
+
+ if (uacpi_unlikely(evh->handler == UACPI_NULL)) {
+ uacpi_warn(
+ "fixed event %d fired but no handler installed, disabling...\n",
+ event
+ );
+ uacpi_write_register_field(ev->enable_field, UACPI_EVENT_DISABLED);
+ return UACPI_INTERRUPT_NOT_HANDLED;
+ }
+
+ return evh->handler(evh->ctx);
+}
+
+static uacpi_interrupt_ret handle_fixed_events(void)
+{
+ uacpi_interrupt_ret int_ret = UACPI_INTERRUPT_NOT_HANDLED;
+ uacpi_status ret;
+ uacpi_u64 enable_mask, status_mask;
+ uacpi_size i;
+
+ ret = uacpi_read_register(UACPI_REGISTER_PM1_STS, &status_mask);
+ if (uacpi_unlikely_error(ret))
+ return int_ret;
+
+ ret = uacpi_read_register(UACPI_REGISTER_PM1_EN, &enable_mask);
+ if (uacpi_unlikely_error(ret))
+ return int_ret;
+
+ for (i = 0; i < UACPI_FIXED_EVENT_MAX; ++i)
+ {
+ const struct fixed_event *ev = &fixed_events[i];
+
+ if (!(status_mask & ev->status_mask) ||
+ !(enable_mask & ev->enable_mask))
+ continue;
+
+ int_ret |= dispatch_fixed_event(ev, i);
+ }
+
+ return int_ret;
+}
+
+struct gpe_native_handler {
+ uacpi_gpe_handler cb;
+ uacpi_handle ctx;
+
+ /*
+ * Preserved values to be used for state restoration if this handler is
+ * removed at any point.
+ */
+ uacpi_handle previous_handler;
+ uacpi_u8 previous_triggering : 1;
+ uacpi_u8 previous_handler_type : 3;
+ uacpi_u8 previously_enabled : 1;
+};
+
+struct gpe_implicit_notify_handler {
+ struct gpe_implicit_notify_handler *next;
+ uacpi_namespace_node *device;
+};
+
+#define EVENTS_PER_GPE_REGISTER 8
+
+/*
+ * NOTE:
+ * This API and handler types are inspired by ACPICA, let's not reinvent the
+ * wheel and follow a similar path that people ended up finding useful after
+ * years of dealing with ACPI. Obviously credit goes to them for inventing
+ * "implicit notify" and other neat API.
+ */
+enum gpe_handler_type {
+ GPE_HANDLER_TYPE_NONE = 0,
+ GPE_HANDLER_TYPE_AML_HANDLER = 1,
+ GPE_HANDLER_TYPE_NATIVE_HANDLER = 2,
+ GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW = 3,
+ GPE_HANDLER_TYPE_IMPLICIT_NOTIFY = 4,
+};
+
+struct gp_event {
+ union {
+ struct gpe_native_handler *native_handler;
+ struct gpe_implicit_notify_handler *implicit_handler;
+ uacpi_namespace_node *aml_handler;
+ uacpi_handle *any_handler;
+ };
+
+ struct gpe_register *reg;
+ uacpi_u16 idx;
+
+ // "reference count" of the number of times this event has been enabled
+ uacpi_u8 num_users;
+
+ uacpi_u8 handler_type : 3;
+ uacpi_u8 triggering : 1;
+ uacpi_u8 wake : 1;
+ uacpi_u8 block_interrupts : 1;
+};
+
+struct gpe_register {
+ uacpi_mapped_gas status;
+ uacpi_mapped_gas enable;
+
+ uacpi_u8 runtime_mask;
+ uacpi_u8 wake_mask;
+ uacpi_u8 masked_mask;
+ uacpi_u8 current_mask;
+
+ uacpi_u16 base_idx;
+};
+
+struct gpe_block {
+ struct gpe_block *prev, *next;
+
+ /*
+ * Technically this can only refer to \_GPE, but there's also apparently a
+ * "GPE Block Device" with id "ACPI0006", which is not used by anyone. We
+ * still keep it as a possibility that someone might eventually use it, so
+ * it is supported here.
+ */
+ uacpi_namespace_node *device_node;
+
+ struct gpe_register *registers;
+ struct gp_event *events;
+ struct gpe_interrupt_ctx *irq_ctx;
+
+ uacpi_u16 num_registers;
+ uacpi_u16 num_events;
+ uacpi_u16 base_idx;
+};
+
+struct gpe_interrupt_ctx {
+ struct gpe_interrupt_ctx *prev, *next;
+
+ struct gpe_block *gpe_head;
+ uacpi_handle irq_handle;
+ uacpi_u32 irq;
+};
+static struct gpe_interrupt_ctx *g_gpe_interrupt_head;
+
+static uacpi_u8 gpe_get_mask(struct gp_event *event)
+{
+ return 1 << (event->idx - event->reg->base_idx);
+}
+
+enum gpe_state {
+ GPE_STATE_ENABLED,
+ GPE_STATE_ENABLED_CONDITIONALLY,
+ GPE_STATE_DISABLED,
+};
+
+static uacpi_status set_gpe_state(struct gp_event *event, enum gpe_state state)
+{
+ uacpi_status ret;
+ struct gpe_register *reg = event->reg;
+ uacpi_u64 enable_mask;
+ uacpi_u8 event_bit;
+ uacpi_cpu_flags flags;
+
+ event_bit = gpe_get_mask(event);
+ if (state != GPE_STATE_DISABLED && (reg->masked_mask & event_bit))
+ return UACPI_STATUS_OK;
+
+ if (state == GPE_STATE_ENABLED_CONDITIONALLY) {
+ if (!(reg->current_mask & event_bit))
+ return UACPI_STATUS_OK;
+
+ state = GPE_STATE_ENABLED;
+ }
+
+ flags = uacpi_kernel_lock_spinlock(g_gpe_state_slock);
+
+ ret = uacpi_gas_read_mapped(&reg->enable, &enable_mask);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ switch (state) {
+ case GPE_STATE_ENABLED:
+ enable_mask |= event_bit;
+ break;
+ case GPE_STATE_DISABLED:
+ enable_mask &= ~event_bit;
+ break;
+ default:
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ ret = uacpi_gas_write_mapped(&reg->enable, enable_mask);
+out:
+ uacpi_kernel_unlock_spinlock(g_gpe_state_slock, flags);
+ return ret;
+}
+
+static uacpi_status clear_gpe(struct gp_event *event)
+{
+ struct gpe_register *reg = event->reg;
+
+ return uacpi_gas_write_mapped(&reg->status, gpe_get_mask(event));
+}
+
+static uacpi_status restore_gpe(struct gp_event *event)
+{
+ uacpi_status ret;
+
+ if (event->triggering == UACPI_GPE_TRIGGERING_LEVEL) {
+ ret = clear_gpe(event);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ ret = set_gpe_state(event, GPE_STATE_ENABLED_CONDITIONALLY);
+ event->block_interrupts = UACPI_FALSE;
+
+ return ret;
+}
+
+static void async_restore_gpe(uacpi_handle opaque)
+{
+ uacpi_status ret;
+ struct gp_event *event = opaque;
+
+ ret = restore_gpe(event);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to restore GPE(%02X): %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ }
+}
+
+static void async_run_gpe_handler(uacpi_handle opaque)
+{
+ uacpi_status ret;
+ struct gp_event *event = opaque;
+
+ ret = uacpi_namespace_write_lock();
+ if (uacpi_unlikely_error(ret))
+ goto out_no_unlock;
+
+ switch (event->handler_type) {
+ case GPE_HANDLER_TYPE_AML_HANDLER: {
+ uacpi_object *method_obj;
+ uacpi_object_name name;
+
+ method_obj = uacpi_namespace_node_get_object_typed(
+ event->aml_handler, UACPI_OBJECT_METHOD_BIT
+ );
+ if (uacpi_unlikely(method_obj == UACPI_NULL)) {
+ uacpi_error("GPE(%02X) AML handler gone\n", event->idx);
+ break;
+ }
+
+ name = uacpi_namespace_node_name(event->aml_handler);
+ uacpi_trace(
+ "executing GPE(%02X) handler %.4s\n",
+ event->idx, name.text
+ );
+
+ ret = uacpi_execute_control_method(
+ event->aml_handler, method_obj->method, UACPI_NULL, UACPI_NULL
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error(
+ "error while executing GPE(%02X) handler %.4s: %s\n",
+ event->idx, event->aml_handler->name.text,
+ uacpi_status_to_string(ret)
+ );
+ }
+ break;
+ }
+
+ case GPE_HANDLER_TYPE_IMPLICIT_NOTIFY: {
+ struct gpe_implicit_notify_handler *handler;
+
+ handler = event->implicit_handler;
+ while (handler) {
+ /*
+ * 2 - Device Wake. Used to notify OSPM that the device has signaled
+ * its wake event, and that OSPM needs to notify OSPM native device
+ * driver for the device.
+ */
+ uacpi_notify_all(handler->device, 2);
+ handler = handler->next;
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+
+ uacpi_namespace_write_unlock();
+
+out_no_unlock:
+ /*
+ * We schedule the work as NOTIFICATION to make sure all other notifications
+ * finish before this GPE is re-enabled.
+ */
+ ret = uacpi_kernel_schedule_work(
+ UACPI_WORK_NOTIFICATION, async_restore_gpe, event
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to schedule GPE(%02X) restore: %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ async_restore_gpe(event);
+ }
+}
+
+static uacpi_interrupt_ret dispatch_gpe(
+ uacpi_namespace_node *device_node, struct gp_event *event
+)
+{
+ uacpi_status ret;
+ uacpi_interrupt_ret int_ret = UACPI_INTERRUPT_NOT_HANDLED;
+
+ /*
+ * For raw handlers we don't do any management whatsoever, we just let the
+ * handler know a GPE has triggered and let it handle disable/enable as
+ * well as clearing.
+ */
+ if (event->handler_type == GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW) {
+ return event->native_handler->cb(
+ event->native_handler->ctx, device_node, event->idx
+ );
+ }
+
+ ret = set_gpe_state(event, GPE_STATE_DISABLED);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("failed to disable GPE(%02X): %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ return int_ret;
+ }
+
+ event->block_interrupts = UACPI_TRUE;
+
+ if (event->triggering == UACPI_GPE_TRIGGERING_EDGE) {
+ ret = clear_gpe(event);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to clear GPE(%02X): %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ set_gpe_state(event, GPE_STATE_ENABLED_CONDITIONALLY);
+ return int_ret;
+ }
+ }
+
+ switch (event->handler_type) {
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER:
+ int_ret = event->native_handler->cb(
+ event->native_handler->ctx, device_node, event->idx
+ );
+ if (!(int_ret & UACPI_GPE_REENABLE))
+ break;
+
+ ret = restore_gpe(event);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to restore GPE(%02X): %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ }
+ break;
+
+ case GPE_HANDLER_TYPE_AML_HANDLER:
+ case GPE_HANDLER_TYPE_IMPLICIT_NOTIFY:
+ ret = uacpi_kernel_schedule_work(
+ UACPI_WORK_GPE_EXECUTION, async_run_gpe_handler, event
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_warn(
+ "unable to schedule GPE(%02X) for execution: %s\n",
+ event->idx, uacpi_status_to_string(ret)
+ );
+ }
+ break;
+
+ default:
+ uacpi_warn("GPE(%02X) fired but no handler, keeping disabled\n",
+ event->idx);
+ break;
+ }
+
+ return UACPI_INTERRUPT_HANDLED;
+}
+
+static uacpi_interrupt_ret detect_gpes(struct gpe_block *block)
+{
+ uacpi_status ret;
+ uacpi_interrupt_ret int_ret = UACPI_INTERRUPT_NOT_HANDLED;
+ struct gpe_register *reg;
+ struct gp_event *event;
+ uacpi_u64 status, enable;
+ uacpi_size i, j;
+
+ while (block) {
+ for (i = 0; i < block->num_registers; ++i) {
+ reg = &block->registers[i];
+
+ if (!reg->runtime_mask && !reg->wake_mask)
+ continue;
+
+ ret = uacpi_gas_read_mapped(&reg->status, &status);
+ if (uacpi_unlikely_error(ret))
+ return int_ret;
+
+ ret = uacpi_gas_read_mapped(&reg->enable, &enable);
+ if (uacpi_unlikely_error(ret))
+ return int_ret;
+
+ if (status == 0)
+ continue;
+
+ for (j = 0; j < EVENTS_PER_GPE_REGISTER; ++j) {
+ if (!((status & enable) & (1ull << j)))
+ continue;
+
+ event = &block->events[j + i * EVENTS_PER_GPE_REGISTER];
+ int_ret |= dispatch_gpe(block->device_node, event);
+ }
+ }
+
+ block = block->next;
+ }
+
+ return int_ret;
+}
+
+static uacpi_status maybe_dispatch_gpe(
+ uacpi_namespace_node *gpe_device, struct gp_event *event
+)
+{
+ uacpi_status ret;
+ struct gpe_register *reg = event->reg;
+ uacpi_u64 status;
+
+ ret = uacpi_gas_read_mapped(&reg->status, &status);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (!(status & gpe_get_mask(event)))
+ return ret;
+
+ dispatch_gpe(gpe_device, event);
+ return ret;
+}
+
+static uacpi_interrupt_ret handle_gpes(uacpi_handle opaque)
+{
+ struct gpe_interrupt_ctx *ctx = opaque;
+
+ if (uacpi_unlikely(ctx == UACPI_NULL))
+ return UACPI_INTERRUPT_NOT_HANDLED;
+
+ return detect_gpes(ctx->gpe_head);
+}
+
+static uacpi_status find_or_create_gpe_interrupt_ctx(
+ uacpi_u32 irq, struct gpe_interrupt_ctx **out_ctx
+)
+{
+ uacpi_status ret;
+ struct gpe_interrupt_ctx *entry = g_gpe_interrupt_head;
+
+ while (entry) {
+ if (entry->irq == irq) {
+ *out_ctx = entry;
+ return UACPI_STATUS_OK;
+ }
+
+ entry = entry->next;
+ }
+
+ entry = uacpi_kernel_alloc_zeroed(sizeof(*entry));
+ if (uacpi_unlikely(entry == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ /*
+ * SCI interrupt is installed by other code and is responsible for more
+ * things than just the GPE handling. Don't install it here.
+ */
+ if (irq != g_uacpi_rt_ctx.fadt.sci_int) {
+ ret = uacpi_kernel_install_interrupt_handler(
+ irq, handle_gpes, entry, &entry->irq_handle
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free(entry, sizeof(*entry));
+ return ret;
+ }
+ }
+
+ entry->irq = irq;
+ entry->next = g_gpe_interrupt_head;
+ g_gpe_interrupt_head = entry;
+
+ *out_ctx = entry;
+ return UACPI_STATUS_OK;
+}
+
+static void gpe_release_implicit_notify_handlers(struct gp_event *event)
+{
+ struct gpe_implicit_notify_handler *handler, *next_handler;
+
+ handler = event->implicit_handler;
+ while (handler) {
+ next_handler = handler->next;
+ uacpi_free(handler, sizeof(*handler));
+ handler = next_handler;
+ }
+
+ event->implicit_handler = UACPI_NULL;
+}
+
+enum gpe_block_action
+{
+ GPE_BLOCK_ACTION_DISABLE_ALL,
+ GPE_BLOCK_ACTION_ENABLE_ALL_FOR_RUNTIME,
+ GPE_BLOCK_ACTION_ENABLE_ALL_FOR_WAKE,
+ GPE_BLOCK_ACTION_CLEAR_ALL,
+};
+
+static uacpi_status gpe_block_apply_action(
+ struct gpe_block *block, enum gpe_block_action action
+)
+{
+ uacpi_status ret;
+ uacpi_size i;
+ uacpi_u8 value;
+ struct gpe_register *reg;
+
+ for (i = 0; i < block->num_registers; ++i) {
+ reg = &block->registers[i];
+
+ switch (action) {
+ case GPE_BLOCK_ACTION_DISABLE_ALL:
+ value = 0;
+ break;
+ case GPE_BLOCK_ACTION_ENABLE_ALL_FOR_RUNTIME:
+ value = reg->runtime_mask & ~reg->masked_mask;
+ break;
+ case GPE_BLOCK_ACTION_ENABLE_ALL_FOR_WAKE:
+ value = reg->wake_mask;
+ break;
+ case GPE_BLOCK_ACTION_CLEAR_ALL:
+ ret = uacpi_gas_write_mapped(&reg->status, 0xFF);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ continue;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ reg->current_mask = value;
+ ret = uacpi_gas_write_mapped(&reg->enable, value);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static void gpe_block_mask_safe(struct gpe_block *block)
+{
+ uacpi_size i;
+ struct gpe_register *reg;
+
+ for (i = 0; i < block->num_registers; ++i) {
+ reg = &block->registers[i];
+
+ // No need to flush or do anything if it's not currently enabled
+ if (!reg->current_mask)
+ continue;
+
+ // 1. Mask the GPEs, this makes sure their state is no longer modifyable
+ reg->masked_mask = 0xFF;
+
+ /*
+ * 2. Wait for in-flight work & IRQs to finish, these might already
+ * be past the respective "if (masked)" check and therefore may
+ * try to re-enable a masked GPE.
+ */
+ uacpi_kernel_wait_for_work_completion();
+
+ /*
+ * 3. Now that this GPE's state is unmodifyable and we know that
+ * currently in-flight IRQs will see the masked state, we can
+ * safely disable all events knowing they won't be re-enabled by
+ * a racing IRQ.
+ */
+ uacpi_gas_write_mapped(&reg->enable, 0x00);
+
+ /*
+ * 4. Wait for the last possible IRQ to finish, now that this event is
+ * disabled.
+ */
+ uacpi_kernel_wait_for_work_completion();
+ }
+}
+
+static void uninstall_gpe_block(struct gpe_block *block)
+{
+ if (block->registers != UACPI_NULL) {
+ struct gpe_register *reg;
+ uacpi_size i;
+
+ gpe_block_mask_safe(block);
+
+ for (i = 0; i < block->num_registers; ++i) {
+ reg = &block->registers[i];
+
+ if (reg->enable.total_bit_width)
+ uacpi_unmap_gas_nofree(&reg->enable);
+ if (reg->status.total_bit_width)
+ uacpi_unmap_gas_nofree(&reg->status);
+ }
+ }
+
+ if (block->prev)
+ block->prev->next = block->next;
+
+ if (block->irq_ctx) {
+ struct gpe_interrupt_ctx *ctx = block->irq_ctx;
+
+ // Are we the first GPE block?
+ if (block == ctx->gpe_head) {
+ ctx->gpe_head = ctx->gpe_head->next;
+ } else {
+ struct gpe_block *prev_block = ctx->gpe_head;
+
+ // We're not, do a search
+ while (prev_block) {
+ if (prev_block->next == block) {
+ prev_block->next = block->next;
+ break;
+ }
+
+ prev_block = prev_block->next;
+ }
+ }
+
+ // This GPE block was the last user of this interrupt context, remove it
+ if (ctx->gpe_head == UACPI_NULL) {
+ if (ctx->prev)
+ ctx->prev->next = ctx->next;
+
+ if (ctx->irq != g_uacpi_rt_ctx.fadt.sci_int) {
+ uacpi_kernel_uninstall_interrupt_handler(
+ handle_gpes, ctx->irq_handle
+ );
+ }
+
+ uacpi_free(block->irq_ctx, sizeof(*block->irq_ctx));
+ }
+ }
+
+ if (block->events != UACPI_NULL) {
+ uacpi_size i;
+ struct gp_event *event;
+
+ for (i = 0; i < block->num_events; ++i) {
+ event = &block->events[i];
+
+ switch (event->handler_type) {
+ case GPE_HANDLER_TYPE_NONE:
+ case GPE_HANDLER_TYPE_AML_HANDLER:
+ break;
+
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER:
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW:
+ uacpi_free(event->native_handler,
+ sizeof(*event->native_handler));
+ break;
+
+ case GPE_HANDLER_TYPE_IMPLICIT_NOTIFY: {
+ gpe_release_implicit_notify_handlers(event);
+ break;
+ }
+
+ default:
+ break;
+ }
+ }
+
+ }
+
+ uacpi_free(block->registers,
+ sizeof(*block->registers) * block->num_registers);
+ uacpi_free(block->events,
+ sizeof(*block->events) * block->num_events);
+ uacpi_free(block, sizeof(*block));
+}
+
+static struct gp_event *gpe_from_block(struct gpe_block *block, uacpi_u16 idx)
+{
+ uacpi_u16 offset;
+
+ if (idx < block->base_idx)
+ return UACPI_NULL;
+
+ offset = idx - block->base_idx;
+ if (offset > block->num_events)
+ return UACPI_NULL;
+
+ return &block->events[offset];
+}
+
+struct gpe_match_ctx {
+ struct gpe_block *block;
+ uacpi_u32 matched_count;
+ uacpi_bool post_dynamic_table_load;
+};
+
+static uacpi_iteration_decision do_match_gpe_methods(
+ uacpi_handle opaque, uacpi_namespace_node *node, uacpi_u32 depth
+)
+{
+ uacpi_status ret;
+ struct gpe_match_ctx *ctx = opaque;
+ struct gp_event *event;
+ uacpi_u8 triggering;
+ uacpi_u64 idx;
+
+ UACPI_UNUSED(depth);
+
+ if (node->name.text[0] != '_')
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ switch (node->name.text[1]) {
+ case 'L':
+ triggering = UACPI_GPE_TRIGGERING_LEVEL;
+ break;
+ case 'E':
+ triggering = UACPI_GPE_TRIGGERING_EDGE;
+ break;
+ default:
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ ret = uacpi_string_to_integer(&node->name.text[2], 2, UACPI_BASE_HEX, &idx);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_trace("invalid GPE method name %.4s, ignored\n", node->name.text);
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ event = gpe_from_block(ctx->block, idx);
+ if (event == UACPI_NULL)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ switch (event->handler_type) {
+ /*
+ * This had implicit notify configured but this is no longer needed as we
+ * now have an actual AML handler. Free the implicit notify list and switch
+ * this handler to AML mode.
+ */
+ case GPE_HANDLER_TYPE_IMPLICIT_NOTIFY:
+ gpe_release_implicit_notify_handlers(event);
+ UACPI_FALLTHROUGH;
+ case GPE_HANDLER_TYPE_NONE:
+ event->aml_handler = node;
+ event->handler_type = GPE_HANDLER_TYPE_AML_HANDLER;
+ break;
+
+ case GPE_HANDLER_TYPE_AML_HANDLER:
+ // This is okay, since we're re-running the detection code
+ if (!ctx->post_dynamic_table_load) {
+ uacpi_warn(
+ "GPE(%02X) already matched %.4s, skipping %.4s\n",
+ (uacpi_u32)idx, event->aml_handler->name.text, node->name.text
+ );
+ }
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER:
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW:
+ uacpi_trace(
+ "not assigning GPE(%02X) to %.4s, override "
+ "installed by user\n", (uacpi_u32)idx, node->name.text
+ );
+ UACPI_FALLTHROUGH;
+ default:
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ uacpi_trace("assigned GPE(%02X) -> %.4s\n",
+ (uacpi_u32)idx, node->name.text);
+ event->triggering = triggering;
+ ctx->matched_count++;
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+void uacpi_events_match_post_dynamic_table_load(void)
+{
+ struct gpe_match_ctx match_ctx = {
+ .post_dynamic_table_load = UACPI_TRUE,
+ };
+ struct gpe_interrupt_ctx *irq_ctx;
+
+ uacpi_namespace_write_unlock();
+
+ if (uacpi_unlikely_error(uacpi_recursive_lock_acquire(&g_event_lock)))
+ goto out;
+
+ irq_ctx = g_gpe_interrupt_head;
+
+ while (irq_ctx) {
+ match_ctx.block = irq_ctx->gpe_head;
+
+ while (match_ctx.block) {
+ uacpi_namespace_do_for_each_child(
+ match_ctx.block->device_node, do_match_gpe_methods, UACPI_NULL,
+ UACPI_OBJECT_METHOD_BIT, UACPI_MAX_DEPTH_ANY,
+ UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, &match_ctx
+ );
+ match_ctx.block = match_ctx.block->next;
+ }
+
+ irq_ctx = irq_ctx->next;
+ }
+
+ if (match_ctx.matched_count) {
+ uacpi_info("matched %u additional GPEs post dynamic table load\n",
+ match_ctx.matched_count);
+ }
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ uacpi_namespace_write_lock();
+}
+
+static uacpi_status create_gpe_block(
+ uacpi_namespace_node *device_node, uacpi_u32 irq, uacpi_u16 base_idx,
+ uacpi_u64 address, uacpi_u8 address_space_id, uacpi_u16 num_registers
+)
+{
+ uacpi_status ret = UACPI_STATUS_OUT_OF_MEMORY;
+ struct gpe_match_ctx match_ctx = { 0 };
+ struct gpe_block *block;
+ struct gpe_register *reg;
+ struct gp_event *event;
+ struct acpi_gas tmp_gas = { 0 };
+ uacpi_size i, j;
+
+ tmp_gas.address_space_id = address_space_id;
+ tmp_gas.register_bit_width = 8;
+
+ block = uacpi_kernel_alloc_zeroed(sizeof(*block));
+ if (uacpi_unlikely(block == UACPI_NULL))
+ return ret;
+
+ block->device_node = device_node;
+ block->base_idx = base_idx;
+
+ block->num_registers = num_registers;
+ block->registers = uacpi_kernel_alloc_zeroed(
+ num_registers * sizeof(*block->registers)
+ );
+ if (uacpi_unlikely(block->registers == UACPI_NULL))
+ goto error_out;
+
+ block->num_events = num_registers * EVENTS_PER_GPE_REGISTER;
+ block->events = uacpi_kernel_alloc_zeroed(
+ block->num_events * sizeof(*block->events)
+ );
+ if (uacpi_unlikely(block->events == UACPI_NULL))
+ goto error_out;
+
+ for (reg = block->registers, event = block->events, i = 0;
+ i < num_registers; ++i, ++reg) {
+
+ /*
+ * Initialize this register pair as well as all the events within it.
+ *
+ * Each register has two sub registers: status & enable, 8 bits each.
+ * Each bit corresponds to one event that we initialize below.
+ */
+ reg->base_idx = base_idx + (i * EVENTS_PER_GPE_REGISTER);
+
+
+ tmp_gas.address = address + i;
+ ret = uacpi_map_gas_noalloc(&tmp_gas, &reg->status);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ tmp_gas.address += num_registers;
+ ret = uacpi_map_gas_noalloc(&tmp_gas, &reg->enable);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ for (j = 0; j < EVENTS_PER_GPE_REGISTER; ++j, ++event) {
+ event->idx = reg->base_idx + j;
+ event->reg = reg;
+ }
+
+ /*
+ * Disable all GPEs in this register & clear anything that might be
+ * pending from earlier.
+ */
+ ret = uacpi_gas_write_mapped(&reg->enable, 0x00);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ ret = uacpi_gas_write_mapped(&reg->status, 0xFF);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+ }
+
+ ret = find_or_create_gpe_interrupt_ctx(irq, &block->irq_ctx);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ block->next = block->irq_ctx->gpe_head;
+ block->irq_ctx->gpe_head = block;
+ match_ctx.block = block;
+
+ uacpi_namespace_do_for_each_child(
+ device_node, do_match_gpe_methods, UACPI_NULL,
+ UACPI_OBJECT_METHOD_BIT, UACPI_MAX_DEPTH_ANY,
+ UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, &match_ctx
+ );
+
+ uacpi_trace("initialized GPE block %.4s[%d->%d], %d AML handlers (IRQ %d)\n",
+ device_node->name.text, base_idx, base_idx + block->num_events,
+ match_ctx.matched_count, irq);
+ return UACPI_STATUS_OK;
+
+error_out:
+ uninstall_gpe_block(block);
+ return ret;
+}
+
+typedef uacpi_iteration_decision (*gpe_block_iteration_callback)
+ (struct gpe_block*, uacpi_handle);
+
+static void for_each_gpe_block(
+ gpe_block_iteration_callback cb, uacpi_handle handle
+)
+{
+ uacpi_iteration_decision decision;
+ struct gpe_interrupt_ctx *irq_ctx = g_gpe_interrupt_head;
+ struct gpe_block *block;
+
+ while (irq_ctx) {
+ block = irq_ctx->gpe_head;
+
+ while (block) {
+ decision = cb(block, handle);
+ if (decision == UACPI_ITERATION_DECISION_BREAK)
+ return;
+
+ block = block->next;
+ }
+
+ irq_ctx = irq_ctx->next;
+ }
+}
+
+struct gpe_search_ctx {
+ uacpi_namespace_node *gpe_device;
+ uacpi_u16 idx;
+ struct gpe_block *out_block;
+ struct gp_event *out_event;
+};
+
+static uacpi_iteration_decision do_find_gpe(
+ struct gpe_block *block, uacpi_handle opaque
+)
+{
+ struct gpe_search_ctx *ctx = opaque;
+
+ if (block->device_node != ctx->gpe_device)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ ctx->out_block = block;
+ ctx->out_event = gpe_from_block(block, ctx->idx);
+ if (ctx->out_event == UACPI_NULL)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ return UACPI_ITERATION_DECISION_BREAK;
+}
+
+static struct gp_event *get_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ struct gpe_search_ctx ctx = { 0 };
+
+ ctx.gpe_device = gpe_device;
+ ctx.idx = idx;
+
+ for_each_gpe_block(do_find_gpe, &ctx);
+ return ctx.out_event;
+}
+
+static void gp_event_toggle_masks(struct gp_event *event, uacpi_bool set_on)
+{
+ uacpi_u8 this_mask;
+ struct gpe_register *reg = event->reg;
+
+ this_mask = gpe_get_mask(event);
+
+ if (set_on) {
+ reg->runtime_mask |= this_mask;
+ reg->current_mask = reg->runtime_mask;
+ return;
+ }
+
+ reg->runtime_mask &= ~this_mask;
+ reg->current_mask = reg->runtime_mask;
+}
+
+static uacpi_status gpe_remove_user(struct gp_event *event)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (uacpi_unlikely(event->num_users == 0))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (--event->num_users == 0) {
+ gp_event_toggle_masks(event, UACPI_FALSE);
+
+ ret = set_gpe_state(event, GPE_STATE_DISABLED);
+ if (uacpi_unlikely_error(ret)) {
+ gp_event_toggle_masks(event, UACPI_TRUE);
+ event->num_users++;
+ }
+ }
+
+ return ret;
+}
+
+enum event_clear_if_first {
+ EVENT_CLEAR_IF_FIRST_YES,
+ EVENT_CLEAR_IF_FIRST_NO,
+};
+
+static uacpi_status gpe_add_user(
+ struct gp_event *event, enum event_clear_if_first clear_if_first
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (uacpi_unlikely(event->num_users == 0xFF))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (++event->num_users == 1) {
+ if (clear_if_first == EVENT_CLEAR_IF_FIRST_YES)
+ clear_gpe(event);
+
+ gp_event_toggle_masks(event, UACPI_TRUE);
+
+ ret = set_gpe_state(event, GPE_STATE_ENABLED);
+ if (uacpi_unlikely_error(ret)) {
+ gp_event_toggle_masks(event, UACPI_FALSE);
+ event->num_users--;
+ }
+ }
+
+ return ret;
+}
+
+const uacpi_char *uacpi_gpe_triggering_to_string(
+ uacpi_gpe_triggering triggering
+)
+{
+ switch (triggering) {
+ case UACPI_GPE_TRIGGERING_EDGE:
+ return "edge";
+ case UACPI_GPE_TRIGGERING_LEVEL:
+ return "level";
+ default:
+ return "invalid";
+ }
+}
+
+static uacpi_bool gpe_needs_polling(struct gp_event *event)
+{
+ return event->num_users && event->triggering == UACPI_GPE_TRIGGERING_EDGE;
+}
+
+static uacpi_status gpe_mask_unmask(
+ struct gp_event *event, uacpi_bool should_mask
+)
+{
+ struct gpe_register *reg;
+ uacpi_u8 mask;
+
+ reg = event->reg;
+ mask = gpe_get_mask(event);
+
+ if (should_mask) {
+ if (reg->masked_mask & mask)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ // 1. Mask the GPE, this makes sure its state is no longer modifyable
+ reg->masked_mask |= mask;
+
+ /*
+ * 2. Wait for in-flight work & IRQs to finish, these might already
+ * be past the respective "if (masked)" check and therefore may
+ * try to re-enable a masked GPE.
+ */
+ uacpi_kernel_wait_for_work_completion();
+
+ /*
+ * 3. Now that this GPE's state is unmodifyable and we know that currently
+ * in-flight IRQs will see the masked state, we can safely disable this
+ * event knowing it won't be re-enabled by a racing IRQ.
+ */
+ set_gpe_state(event, GPE_STATE_DISABLED);
+
+ /*
+ * 4. Wait for the last possible IRQ to finish, now that this event is
+ * disabled.
+ */
+ uacpi_kernel_wait_for_work_completion();
+
+ return UACPI_STATUS_OK;
+ }
+
+ if (!(reg->masked_mask & mask))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ reg->masked_mask &= ~mask;
+ if (!event->block_interrupts && event->num_users)
+ set_gpe_state(event, GPE_STATE_ENABLED_CONDITIONALLY);
+
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * Safely mask the event before we modify its handlers.
+ *
+ * This makes sure we can't get an IRQ in the middle of modifying this
+ * event's structures.
+ */
+static uacpi_bool gpe_mask_safe(struct gp_event *event)
+{
+ // No need to flush or do anything if it's not currently enabled
+ if (!(event->reg->current_mask & gpe_get_mask(event)))
+ return UACPI_FALSE;
+
+ gpe_mask_unmask(event, UACPI_TRUE);
+ return UACPI_TRUE;
+}
+
+static uacpi_iteration_decision do_initialize_gpe_block(
+ struct gpe_block *block, uacpi_handle opaque
+)
+{
+ uacpi_status ret;
+ uacpi_bool *poll_blocks = opaque;
+ uacpi_size i, j, count_enabled = 0;
+ struct gp_event *event;
+
+ for (i = 0; i < block->num_registers; ++i) {
+ for (j = 0; j < EVENTS_PER_GPE_REGISTER; ++j) {
+ event = &block->events[j + i * EVENTS_PER_GPE_REGISTER];
+
+ if (event->wake ||
+ event->handler_type != GPE_HANDLER_TYPE_AML_HANDLER)
+ continue;
+
+ ret = gpe_add_user(event, EVENT_CLEAR_IF_FIRST_NO);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_warn("failed to enable GPE(%02X): %s\n",
+ event->idx, uacpi_status_to_string(ret));
+ continue;
+ }
+
+ *poll_blocks |= gpe_needs_polling(event);
+ count_enabled++;
+ }
+ }
+
+ if (count_enabled) {
+ uacpi_info(
+ "enabled %zu GPEs in block %.4s@[%d->%d]\n",
+ count_enabled, block->device_node->name.text,
+ block->base_idx, block->base_idx + block->num_events
+ );
+ }
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+uacpi_status uacpi_finalize_gpe_initialization(void)
+{
+ uacpi_status ret;
+ uacpi_bool poll_blocks = UACPI_FALSE;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (g_gpes_finalized)
+ goto out;
+
+ g_gpes_finalized = UACPI_TRUE;
+
+ for_each_gpe_block(do_initialize_gpe_block, &poll_blocks);
+ if (poll_blocks)
+ detect_gpes(g_gpe_interrupt_head->gpe_head);
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+static uacpi_status sanitize_device_and_find_gpe(
+ uacpi_namespace_node **gpe_device, uacpi_u16 idx,
+ struct gp_event **out_event
+)
+{
+ if (*gpe_device == UACPI_NULL) {
+ *gpe_device = uacpi_namespace_get_predefined(
+ UACPI_PREDEFINED_NAMESPACE_GPE
+ );
+ }
+
+ *out_event = get_gpe(*gpe_device, idx);
+ if (*out_event == UACPI_NULL)
+ return UACPI_STATUS_NOT_FOUND;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status do_install_gpe_handler(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+ uacpi_gpe_triggering triggering, enum gpe_handler_type type,
+ uacpi_gpe_handler handler, uacpi_handle ctx
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+ struct gpe_native_handler *native_handler;
+ uacpi_bool did_mask;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ if (uacpi_unlikely(triggering > UACPI_GPE_TRIGGERING_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (event->handler_type == GPE_HANDLER_TYPE_NATIVE_HANDLER ||
+ event->handler_type == GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW) {
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out;
+ }
+
+ native_handler = uacpi_kernel_alloc(sizeof(*native_handler));
+ if (uacpi_unlikely(native_handler == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+
+ native_handler->cb = handler;
+ native_handler->ctx = ctx;
+ native_handler->previous_handler = event->any_handler;
+ native_handler->previous_handler_type = event->handler_type;
+ native_handler->previous_triggering = event->triggering;
+ native_handler->previously_enabled = UACPI_FALSE;
+
+ did_mask = gpe_mask_safe(event);
+
+ if ((event->handler_type == GPE_HANDLER_TYPE_AML_HANDLER ||
+ event->handler_type == GPE_HANDLER_TYPE_IMPLICIT_NOTIFY) &&
+ event->num_users != 0) {
+ native_handler->previously_enabled = UACPI_TRUE;
+ gpe_remove_user(event);
+
+ if (uacpi_unlikely(event->triggering != triggering)) {
+ uacpi_warn(
+ "GPE(%02X) user handler claims %s triggering, originally "
+ "configured as %s\n", idx,
+ uacpi_gpe_triggering_to_string(triggering),
+ uacpi_gpe_triggering_to_string(event->triggering)
+ );
+ }
+ }
+
+ event->native_handler = native_handler;
+ event->handler_type = type;
+ event->triggering = triggering;
+
+ if (did_mask)
+ gpe_mask_unmask(event, UACPI_FALSE);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+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
+)
+{
+ return do_install_gpe_handler(
+ gpe_device, idx, triggering, GPE_HANDLER_TYPE_NATIVE_HANDLER,
+ handler, ctx
+ );
+}
+
+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
+)
+{
+ return do_install_gpe_handler(
+ gpe_device, idx, triggering, GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW,
+ handler, ctx
+ );
+}
+
+uacpi_status uacpi_uninstall_gpe_handler(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+ uacpi_gpe_handler handler
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+ struct gpe_native_handler *native_handler;
+ uacpi_bool did_mask;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (event->handler_type != GPE_HANDLER_TYPE_NATIVE_HANDLER &&
+ event->handler_type != GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW) {
+ ret = UACPI_STATUS_NOT_FOUND;
+ goto out;
+ }
+
+ native_handler = event->native_handler;
+ if (uacpi_unlikely(native_handler->cb != handler)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ did_mask = gpe_mask_safe(event);
+
+ event->aml_handler = native_handler->previous_handler;
+ event->triggering = native_handler->previous_triggering;
+ event->handler_type = native_handler->previous_handler_type;
+
+ if ((event->handler_type == GPE_HANDLER_TYPE_AML_HANDLER ||
+ event->handler_type == GPE_HANDLER_TYPE_IMPLICIT_NOTIFY) &&
+ native_handler->previously_enabled) {
+ gpe_add_user(event, EVENT_CLEAR_IF_FIRST_NO);
+ }
+
+ uacpi_free(native_handler, sizeof(*native_handler));
+
+ if (did_mask)
+ gpe_mask_unmask(event, UACPI_FALSE);
+
+ if (gpe_needs_polling(event))
+ maybe_dispatch_gpe(gpe_device, event);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_enable_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (uacpi_unlikely(event->handler_type == GPE_HANDLER_TYPE_NONE)) {
+ ret = UACPI_STATUS_NO_HANDLER;
+ goto out;
+ }
+
+ ret = gpe_add_user(event, EVENT_CLEAR_IF_FIRST_YES);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (gpe_needs_polling(event))
+ maybe_dispatch_gpe(gpe_device, event);
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_disable_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ ret = gpe_remove_user(event);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_clear_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ ret = clear_gpe(event);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+static uacpi_status gpe_suspend_resume(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx, enum gpe_state state
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ event->block_interrupts = state == GPE_STATE_DISABLED;
+ ret = set_gpe_state(event, state);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_suspend_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_suspend_resume(gpe_device, idx, GPE_STATE_DISABLED);
+}
+
+uacpi_status uacpi_resume_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_suspend_resume(gpe_device, idx, GPE_STATE_ENABLED);
+}
+
+uacpi_status uacpi_finish_handling_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ event = get_gpe(gpe_device, idx);
+ if (uacpi_unlikely(event == UACPI_NULL)) {
+ ret = UACPI_STATUS_NOT_FOUND;
+ goto out;
+ }
+
+ ret = restore_gpe(event);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+
+}
+
+static uacpi_status gpe_get_mask_unmask(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx, uacpi_bool should_mask
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ ret = gpe_mask_unmask(event, should_mask);
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_mask_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_get_mask_unmask(gpe_device, idx, UACPI_TRUE);
+}
+
+uacpi_status uacpi_unmask_gpe(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_get_mask_unmask(gpe_device, idx, UACPI_FALSE);
+}
+
+uacpi_status uacpi_setup_gpe_for_wake(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx,
+ uacpi_namespace_node *wake_device
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+ uacpi_bool did_mask;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ if (wake_device != UACPI_NULL) {
+ uacpi_bool is_dev = wake_device == uacpi_namespace_root();
+
+ if (!is_dev) {
+ ret = uacpi_namespace_node_is(wake_device, UACPI_OBJECT_DEVICE, &is_dev);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ if (!is_dev)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ did_mask = gpe_mask_safe(event);
+
+ if (wake_device != UACPI_NULL) {
+ switch (event->handler_type) {
+ case GPE_HANDLER_TYPE_NONE:
+ event->handler_type = GPE_HANDLER_TYPE_IMPLICIT_NOTIFY;
+ event->triggering = UACPI_GPE_TRIGGERING_LEVEL;
+ break;
+
+ case GPE_HANDLER_TYPE_AML_HANDLER:
+ /*
+ * An AML handler already exists, we expect it to call Notify() as
+ * it sees fit. For now just make sure this event is disabled if it
+ * had been enabled automatically previously during initialization.
+ */
+ gpe_remove_user(event);
+ break;
+
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER_RAW:
+ case GPE_HANDLER_TYPE_NATIVE_HANDLER:
+ uacpi_warn(
+ "not configuring implicit notify for GPE(%02X) -> %.4s: "
+ " a user handler already installed\n", event->idx,
+ wake_device->name.text
+ );
+ break;
+
+ // We will re-check this below
+ case GPE_HANDLER_TYPE_IMPLICIT_NOTIFY:
+ break;
+
+ default:
+ uacpi_warn("invalid GPE(%02X) handler type: %d\n",
+ event->idx, event->handler_type);
+ ret = UACPI_STATUS_INTERNAL_ERROR;
+ goto out_unmask;
+ }
+
+ /*
+ * This GPE has no known AML handler, so we configure it to receive
+ * implicit notifications for wake devices when we get a corresponding
+ * GPE triggered. Usually it's the job of a matching AML handler, but
+ * we didn't find any.
+ */
+ if (event->handler_type == GPE_HANDLER_TYPE_IMPLICIT_NOTIFY) {
+ struct gpe_implicit_notify_handler *implicit_handler;
+
+ implicit_handler = event->implicit_handler;
+ while (implicit_handler) {
+ if (implicit_handler->device == wake_device) {
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out_unmask;
+ }
+
+ implicit_handler = implicit_handler->next;
+ }
+
+ implicit_handler = uacpi_kernel_alloc(sizeof(*implicit_handler));
+ if (uacpi_likely(implicit_handler != UACPI_NULL)) {
+ implicit_handler->device = wake_device;
+ implicit_handler->next = event->implicit_handler;
+ event->implicit_handler = implicit_handler;
+ } else {
+ uacpi_warn(
+ "unable to configure implicit wake for GPE(%02X) -> %.4s: "
+ "out of memory\n", event->idx, wake_device->name.text
+ );
+ }
+ }
+ }
+
+ event->wake = UACPI_TRUE;
+
+out_unmask:
+ if (did_mask)
+ gpe_mask_unmask(event, UACPI_FALSE);
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+static uacpi_status gpe_enable_disable_for_wake(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx, uacpi_bool enabled
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+ struct gpe_register *reg;
+ uacpi_u8 mask;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (!event->wake) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ reg = event->reg;
+ mask = gpe_get_mask(event);
+
+ if (enabled)
+ reg->wake_mask |= mask;
+ else
+ reg->wake_mask &= mask;
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_enable_gpe_for_wake(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_enable_disable_for_wake(gpe_device, idx, UACPI_TRUE);
+}
+
+uacpi_status uacpi_disable_gpe_for_wake(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx
+)
+{
+ return gpe_enable_disable_for_wake(gpe_device, idx, UACPI_FALSE);
+}
+
+struct do_for_all_gpes_ctx {
+ enum gpe_block_action action;
+ uacpi_status ret;
+};
+
+static uacpi_iteration_decision do_for_all_gpes(
+ struct gpe_block *block, uacpi_handle opaque
+)
+{
+ struct do_for_all_gpes_ctx *ctx = opaque;
+
+ ctx->ret = gpe_block_apply_action(block, ctx->action);
+ if (uacpi_unlikely_error(ctx->ret))
+ return UACPI_ITERATION_DECISION_BREAK;
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+static uacpi_status for_all_gpes_locked(struct do_for_all_gpes_ctx *ctx)
+{
+ uacpi_status ret;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ for_each_gpe_block(do_for_all_gpes, ctx);
+
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ctx->ret;
+}
+
+uacpi_status uacpi_disable_all_gpes(void)
+{
+ struct do_for_all_gpes_ctx ctx = {
+ .action = GPE_BLOCK_ACTION_DISABLE_ALL,
+ };
+ return for_all_gpes_locked(&ctx);
+}
+
+uacpi_status uacpi_enable_all_runtime_gpes(void)
+{
+ struct do_for_all_gpes_ctx ctx = {
+ .action = GPE_BLOCK_ACTION_ENABLE_ALL_FOR_RUNTIME,
+ };
+ return for_all_gpes_locked(&ctx);
+}
+
+uacpi_status uacpi_enable_all_wake_gpes(void)
+{
+ struct do_for_all_gpes_ctx ctx = {
+ .action = GPE_BLOCK_ACTION_ENABLE_ALL_FOR_WAKE,
+ };
+ return for_all_gpes_locked(&ctx);
+}
+
+static uacpi_status initialize_gpes(void)
+{
+ uacpi_status ret;
+ uacpi_namespace_node *gpe_node;
+ struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+ uacpi_u8 gpe0_regs = 0, gpe1_regs = 0;
+
+ gpe_node = uacpi_namespace_get_predefined(UACPI_PREDEFINED_NAMESPACE_GPE);
+
+ if (fadt->x_gpe0_blk.address && fadt->gpe0_blk_len) {
+ gpe0_regs = fadt->gpe0_blk_len / 2;
+
+ ret = create_gpe_block(
+ gpe_node, fadt->sci_int, 0, fadt->x_gpe0_blk.address,
+ fadt->x_gpe0_blk.address_space_id, gpe0_regs
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to create FADT GPE block 0: %s\n",
+ uacpi_status_to_string(ret));
+ }
+ }
+
+ if (fadt->x_gpe1_blk.address && fadt->gpe1_blk_len) {
+ gpe1_regs = fadt->gpe1_blk_len / 2;
+
+ if (uacpi_unlikely((gpe0_regs * EVENTS_PER_GPE_REGISTER) >
+ fadt->gpe1_base)) {
+ uacpi_error(
+ "FADT GPE block 1 [%d->%d] collides with GPE block 0 "
+ "[%d->%d], ignoring\n",
+ 0, gpe0_regs * EVENTS_PER_GPE_REGISTER, fadt->gpe1_base,
+ gpe1_regs * EVENTS_PER_GPE_REGISTER
+ );
+ gpe1_regs = 0;
+ goto out;
+ }
+
+ ret = create_gpe_block(
+ gpe_node, fadt->sci_int, fadt->gpe1_base, fadt->x_gpe1_blk.address,
+ fadt->x_gpe1_blk.address_space_id, gpe1_regs
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to create FADT GPE block 1: %s\n",
+ uacpi_status_to_string(ret));
+ }
+ }
+
+ if (gpe0_regs == 0 && gpe1_regs == 0)
+ uacpi_trace("platform has no FADT GPE events\n");
+
+out:
+ return UACPI_STATUS_OK;
+}
+
+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_status ret;
+ uacpi_bool is_dev;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_namespace_node_is(gpe_device, UACPI_OBJECT_DEVICE, &is_dev);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ if (!is_dev)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely(get_gpe(gpe_device, 0) != UACPI_NULL)) {
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out;
+ }
+
+ ret = create_gpe_block(
+ gpe_device, irq, 0, address, address_space, num_registers
+ );
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_uninstall_gpe_block(
+ uacpi_namespace_node *gpe_device
+)
+{
+ uacpi_status ret;
+ uacpi_bool is_dev;
+ struct gpe_search_ctx search_ctx = { 0 };
+
+ search_ctx.idx = 0;
+ search_ctx.gpe_device = gpe_device;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_namespace_node_is(gpe_device, UACPI_OBJECT_DEVICE, &is_dev);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ if (!is_dev)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ for_each_gpe_block(do_find_gpe, &search_ctx);
+ if (search_ctx.out_block == UACPI_NULL) {
+ ret = UACPI_STATUS_NOT_FOUND;
+ goto out;
+ }
+
+ uninstall_gpe_block(search_ctx.out_block);
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+static uacpi_interrupt_ret handle_global_lock(uacpi_handle ctx)
+{
+ uacpi_cpu_flags flags;
+ UACPI_UNUSED(ctx);
+
+ if (uacpi_unlikely(!g_uacpi_rt_ctx.has_global_lock)) {
+ uacpi_warn("platform has no global lock but a release event "
+ "was fired anyway?\n");
+ return UACPI_INTERRUPT_HANDLED;
+ }
+
+ flags = uacpi_kernel_lock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock);
+ if (!g_uacpi_rt_ctx.global_lock_pending) {
+ uacpi_trace("spurious firmware global lock release notification\n");
+ goto out;
+ }
+
+ uacpi_trace("received a firmware global lock release notification\n");
+
+ uacpi_kernel_signal_event(g_uacpi_rt_ctx.global_lock_event);
+ g_uacpi_rt_ctx.global_lock_pending = UACPI_FALSE;
+
+out:
+ uacpi_kernel_unlock_spinlock(g_uacpi_rt_ctx.global_lock_spinlock, flags);
+ return UACPI_INTERRUPT_HANDLED;
+}
+
+static uacpi_interrupt_ret handle_sci(uacpi_handle ctx)
+{
+ uacpi_interrupt_ret int_ret = UACPI_INTERRUPT_NOT_HANDLED;
+
+ int_ret |= handle_fixed_events();
+ int_ret |= handle_gpes(ctx);
+
+ return int_ret;
+}
+
+uacpi_status uacpi_initialize_events_early(void)
+{
+ uacpi_status ret;
+
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ g_gpe_state_slock = uacpi_kernel_create_spinlock();
+ if (uacpi_unlikely(g_gpe_state_slock == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = uacpi_recursive_lock_init(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = initialize_fixed_events();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_initialize_events(void)
+{
+ uacpi_status ret;
+
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ ret = initialize_gpes();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_kernel_install_interrupt_handler(
+ g_uacpi_rt_ctx.fadt.sci_int, handle_sci, g_gpe_interrupt_head,
+ &g_uacpi_rt_ctx.sci_handle
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error(
+ "unable to install SCI interrupt handler: %s\n",
+ uacpi_status_to_string(ret)
+ );
+ return ret;
+ }
+ g_uacpi_rt_ctx.sci_handle_valid = UACPI_TRUE;
+
+ g_uacpi_rt_ctx.global_lock_event = uacpi_kernel_create_event();
+ if (uacpi_unlikely(g_uacpi_rt_ctx.global_lock_event == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ g_uacpi_rt_ctx.global_lock_spinlock = uacpi_kernel_create_spinlock();
+ if (uacpi_unlikely(g_uacpi_rt_ctx.global_lock_spinlock == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = uacpi_install_fixed_event_handler(
+ UACPI_FIXED_EVENT_GLOBAL_LOCK, handle_global_lock, UACPI_NULL
+ );
+ if (uacpi_likely_success(ret)) {
+ if (uacpi_unlikely(g_uacpi_rt_ctx.facs == UACPI_NULL)) {
+ uacpi_uninstall_fixed_event_handler(UACPI_FIXED_EVENT_GLOBAL_LOCK);
+ uacpi_warn("platform has global lock but no FACS was provided\n");
+ return ret;
+ }
+ g_uacpi_rt_ctx.has_global_lock = UACPI_TRUE;
+ } else if (ret == UACPI_STATUS_HARDWARE_TIMEOUT) {
+ // has_global_lock remains set to false
+ uacpi_trace("platform has no global lock\n");
+ ret = UACPI_STATUS_OK;
+ }
+
+ return ret;
+}
+
+void uacpi_deinitialize_events(void)
+{
+ struct gpe_interrupt_ctx *ctx, *next_ctx = g_gpe_interrupt_head;
+ uacpi_size i;
+
+ g_gpes_finalized = UACPI_FALSE;
+
+ if (g_uacpi_rt_ctx.sci_handle_valid) {
+ uacpi_kernel_uninstall_interrupt_handler(
+ handle_sci, g_uacpi_rt_ctx.sci_handle
+ );
+ g_uacpi_rt_ctx.sci_handle_valid = UACPI_FALSE;
+ }
+
+ while (next_ctx) {
+ struct gpe_block *block, *next_block;
+
+ ctx = next_ctx;
+ next_ctx = ctx->next;
+
+ next_block = ctx->gpe_head;
+ while (next_block) {
+ block = next_block;
+ next_block = block->next;
+ uninstall_gpe_block(block);
+ }
+ }
+
+ for (i = 0; i < UACPI_FIXED_EVENT_MAX; ++i) {
+ if (fixed_event_handlers[i].handler)
+ uacpi_uninstall_fixed_event_handler(i);
+ }
+
+ if (g_gpe_state_slock != UACPI_NULL) {
+ uacpi_kernel_free_spinlock(g_gpe_state_slock);
+ g_gpe_state_slock = UACPI_NULL;
+ }
+
+ uacpi_recursive_lock_deinit(&g_event_lock);
+
+ g_gpe_interrupt_head = UACPI_NULL;
+}
+
+uacpi_status uacpi_install_fixed_event_handler(
+ uacpi_fixed_event event, uacpi_interrupt_handler handler,
+ uacpi_handle user
+)
+{
+ uacpi_status ret;
+ struct fixed_event_handler *ev;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ev = &fixed_event_handlers[event];
+
+ if (ev->handler != UACPI_NULL) {
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out;
+ }
+
+ ev->handler = handler;
+ ev->ctx = user;
+
+ ret = set_event(event, UACPI_EVENT_ENABLED);
+ if (uacpi_unlikely_error(ret)) {
+ ev->handler = UACPI_NULL;
+ ev->ctx = UACPI_NULL;
+ }
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_uninstall_fixed_event_handler(
+ uacpi_fixed_event event
+)
+{
+ uacpi_status ret;
+ struct fixed_event_handler *ev;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_OK;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ev = &fixed_event_handlers[event];
+
+ ret = set_event(event, UACPI_EVENT_DISABLED);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ uacpi_kernel_wait_for_work_completion();
+
+ ev->handler = UACPI_NULL;
+ ev->ctx = UACPI_NULL;
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_fixed_event_info(
+ uacpi_fixed_event event, uacpi_event_info *out_info
+)
+{
+ uacpi_status ret;
+ const struct fixed_event *ev;
+ uacpi_u64 raw_value;
+ uacpi_event_info info = 0;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(event < 0 || event > UACPI_FIXED_EVENT_MAX))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ if (uacpi_is_hardware_reduced())
+ return UACPI_STATUS_NOT_FOUND;
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (fixed_event_handlers[event].handler != UACPI_NULL)
+ info |= UACPI_EVENT_INFO_HAS_HANDLER;
+
+ ev = &fixed_events[event];
+
+ ret = uacpi_read_register_field(ev->enable_field, &raw_value);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+ if (raw_value)
+ info |= UACPI_EVENT_INFO_ENABLED | UACPI_EVENT_INFO_HW_ENABLED;
+
+ ret = uacpi_read_register_field(ev->status_field, &raw_value);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+ if (raw_value)
+ info |= UACPI_EVENT_INFO_HW_STATUS;
+
+ *out_info = info;
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+uacpi_status uacpi_gpe_info(
+ uacpi_namespace_node *gpe_device, uacpi_u16 idx, uacpi_event_info *out_info
+)
+{
+ uacpi_status ret;
+ struct gp_event *event;
+ struct gpe_register *reg;
+ uacpi_u8 mask;
+ uacpi_u64 raw_value;
+ uacpi_event_info info = 0;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = sanitize_device_and_find_gpe(&gpe_device, idx, &event);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ if (event->handler_type != GPE_HANDLER_TYPE_NONE)
+ info |= UACPI_EVENT_INFO_HAS_HANDLER;
+
+ mask = gpe_get_mask(event);
+ reg = event->reg;
+
+ if (reg->runtime_mask & mask)
+ info |= UACPI_EVENT_INFO_ENABLED;
+ if (reg->masked_mask & mask)
+ info |= UACPI_EVENT_INFO_MASKED;
+ if (reg->wake_mask & mask)
+ info |= UACPI_EVENT_INFO_ENABLED_FOR_WAKE;
+
+ ret = uacpi_gas_read_mapped(&reg->enable, &raw_value);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+ if (raw_value & mask)
+ info |= UACPI_EVENT_INFO_HW_ENABLED;
+
+ ret = uacpi_gas_read_mapped(&reg->status, &raw_value);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+ if (raw_value & mask)
+ info |= UACPI_EVENT_INFO_HW_STATUS;
+
+ *out_info = info;
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+#define PM1_STATUS_BITS ( \
+ ACPI_PM1_STS_TMR_STS_MASK | \
+ ACPI_PM1_STS_BM_STS_MASK | \
+ ACPI_PM1_STS_GBL_STS_MASK | \
+ ACPI_PM1_STS_PWRBTN_STS_MASK | \
+ ACPI_PM1_STS_SLPBTN_STS_MASK | \
+ ACPI_PM1_STS_RTC_STS_MASK | \
+ ACPI_PM1_STS_PCIEXP_WAKE_STS_MASK | \
+ ACPI_PM1_STS_WAKE_STS_MASK \
+)
+
+uacpi_status uacpi_clear_all_events(void)
+{
+ uacpi_status ret;
+ struct do_for_all_gpes_ctx ctx = {
+ .action = GPE_BLOCK_ACTION_CLEAR_ALL,
+ };
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ret = uacpi_recursive_lock_acquire(&g_event_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_write_register(UACPI_REGISTER_PM1_STS, PM1_STATUS_BITS);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ for_each_gpe_block(do_for_all_gpes, &ctx);
+ ret = ctx.ret;
+
+out:
+ uacpi_recursive_lock_release(&g_event_lock);
+ return ret;
+}
+
+#endif // !UACPI_REDUCED_HARDWARE && !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/interpreter.c b/sys/dev/acpi/uacpi/interpreter.c
new file mode 100644
index 0000000..8ffb8d5
--- /dev/null
+++ b/sys/dev/acpi/uacpi/interpreter.c
@@ -0,0 +1,6053 @@
+#include <uacpi/internal/types.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/dynamic_array.h>
+#include <uacpi/internal/opcodes.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/internal/tables.h>
+#include <uacpi/internal/helpers.h>
+#include <uacpi/kernel_api.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/io.h>
+#include <uacpi/internal/notify.h>
+#include <uacpi/internal/resources.h>
+#include <uacpi/internal/event.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/osi.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+enum item_type {
+ ITEM_NONE = 0,
+ ITEM_NAMESPACE_NODE,
+ ITEM_OBJECT,
+ ITEM_EMPTY_OBJECT,
+ ITEM_PACKAGE_LENGTH,
+ ITEM_IMMEDIATE,
+};
+
+struct package_length {
+ uacpi_u32 begin;
+ uacpi_u32 end;
+};
+
+struct item {
+ uacpi_u8 type;
+ union {
+ uacpi_handle handle;
+ uacpi_object *obj;
+ struct uacpi_namespace_node *node;
+ struct package_length pkg;
+ uacpi_u64 immediate;
+ uacpi_u8 immediate_bytes[8];
+ };
+};
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(item_array, struct item, 8)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(item_array, struct item, static)
+
+struct op_context {
+ uacpi_u8 pc;
+ uacpi_bool preempted;
+
+ /*
+ * == 0 -> none
+ * >= 1 -> item[idx - 1]
+ */
+ uacpi_u8 tracked_pkg_idx;
+
+ uacpi_aml_op switched_from;
+
+ const struct uacpi_op_spec *op;
+ struct item_array items;
+};
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(op_context_array, struct op_context, 8)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ op_context_array, struct op_context, static
+)
+
+static struct op_context *op_context_array_one_before_last(
+ struct op_context_array *arr
+)
+{
+ uacpi_size size;
+
+ size = op_context_array_size(arr);
+
+ if (size < 2)
+ return UACPI_NULL;
+
+ return op_context_array_at(arr, size - 2);
+}
+
+enum code_block_type {
+ CODE_BLOCK_IF = 1,
+ CODE_BLOCK_ELSE = 2,
+ CODE_BLOCK_WHILE = 3,
+ CODE_BLOCK_SCOPE = 4,
+};
+
+struct code_block {
+ enum code_block_type type;
+ uacpi_u32 begin, end;
+ union {
+ struct uacpi_namespace_node *node;
+ uacpi_u64 expiration_point;
+ };
+};
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(code_block_array, struct code_block, 8)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ code_block_array, struct code_block, static
+)
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(held_mutexes_array, uacpi_mutex*, 8)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ held_mutexes_array, uacpi_mutex*, static
+)
+
+static uacpi_status held_mutexes_array_push(
+ struct held_mutexes_array *arr, uacpi_mutex *mutex
+)
+{
+ uacpi_mutex **slot;
+
+ slot = held_mutexes_array_alloc(arr);
+ if (uacpi_unlikely(slot == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ *slot = mutex;
+ uacpi_shareable_ref(mutex);
+ return UACPI_STATUS_OK;
+}
+
+static void held_mutexes_array_remove_idx(
+ struct held_mutexes_array *arr, uacpi_size i
+)
+{
+ uacpi_size size;
+
+ size = held_mutexes_array_inline_capacity(arr);
+
+ // Only the dynamic array part is affected
+ if (i >= size) {
+ i -= size;
+ size = arr->size_including_inline - size;
+ size -= i + 1;
+
+ uacpi_memmove(
+ &arr->dynamic_storage[i], &arr->dynamic_storage[i + 1],
+ size * sizeof(arr->inline_storage[0])
+ );
+
+ held_mutexes_array_pop(arr);
+ return;
+ }
+
+ size = UACPI_MIN(held_mutexes_array_inline_capacity(arr),
+ arr->size_including_inline);
+ size -= i + 1;
+ uacpi_memmove(
+ &arr->inline_storage[i], &arr->inline_storage[i + 1],
+ size * sizeof(arr->inline_storage[0])
+ );
+
+ size = held_mutexes_array_size(arr);
+ i = held_mutexes_array_inline_capacity(arr);
+
+ /*
+ * This array has dynamic storage as well, now we have to take the first
+ * dynamic item, move it to the top of inline storage, and then shift all
+ * dynamic items backward by 1 as well.
+ */
+ if (size > i) {
+ arr->inline_storage[i - 1] = arr->dynamic_storage[0];
+ size -= i + 1;
+
+ uacpi_memmove(
+ &arr->dynamic_storage[0], &arr->dynamic_storage[1],
+ size * sizeof(arr->inline_storage[0])
+ );
+ }
+
+ held_mutexes_array_pop(arr);
+}
+
+enum force_release {
+ FORCE_RELEASE_NO,
+ FORCE_RELEASE_YES,
+};
+
+static uacpi_status held_mutexes_array_remove_and_release(
+ struct held_mutexes_array *arr, uacpi_mutex *mutex,
+ enum force_release force
+)
+{
+ uacpi_mutex *item;
+ uacpi_size i;
+
+ if (uacpi_unlikely(held_mutexes_array_size(arr) == 0))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ item = *held_mutexes_array_last(arr);
+
+ if (uacpi_unlikely(item->sync_level != mutex->sync_level &&
+ force != FORCE_RELEASE_YES)) {
+ uacpi_warn(
+ "ignoring mutex @%p release due to sync level mismatch: %d vs %d\n",
+ mutex, mutex->sync_level, item->sync_level
+ );
+
+ // We still return OK because we don't want to abort because of this
+ return UACPI_STATUS_OK;
+ }
+
+ if (mutex->depth > 1 && force == FORCE_RELEASE_NO) {
+ uacpi_release_aml_mutex(mutex);
+ return UACPI_STATUS_OK;
+ }
+
+ // Fast path for well-behaved AML that releases mutexes in descending order
+ if (uacpi_likely(item == mutex)) {
+ held_mutexes_array_pop(arr);
+ goto do_release;
+ }
+
+ /*
+ * The mutex being released is not the last one acquired, although we did
+ * verify that at least it has the same sync level. Anyway, now we have
+ * to search for it and then remove it from the array while shifting
+ * everything backwards.
+ */
+ i = held_mutexes_array_size(arr);
+ for (;;) {
+ item = *held_mutexes_array_at(arr, --i);
+ if (item == mutex)
+ break;
+
+ if (uacpi_unlikely(i == 0))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ held_mutexes_array_remove_idx(arr, i);
+
+do_release:
+ // This is either a force release, or depth was already 1 to begin with
+ mutex->depth = 1;
+ uacpi_release_aml_mutex(mutex);
+
+ uacpi_mutex_unref(mutex);
+ return UACPI_STATUS_OK;
+}
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(
+ temp_namespace_node_array, uacpi_namespace_node*, 8)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ temp_namespace_node_array, uacpi_namespace_node*, static
+)
+
+static uacpi_status temp_namespace_node_array_push(
+ struct temp_namespace_node_array *arr, uacpi_namespace_node *node
+)
+{
+ uacpi_namespace_node **slot;
+
+ slot = temp_namespace_node_array_alloc(arr);
+ if (uacpi_unlikely(slot == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ *slot = node;
+ return UACPI_STATUS_OK;
+}
+
+struct call_frame {
+ struct uacpi_control_method *method;
+
+ uacpi_object *args[7];
+ uacpi_object *locals[8];
+
+ struct op_context_array pending_ops;
+ struct code_block_array code_blocks;
+ struct temp_namespace_node_array temp_nodes;
+ struct code_block *last_while;
+ uacpi_u64 prev_while_expiration;
+ uacpi_u32 prev_while_code_offset;
+
+ uacpi_u32 code_offset;
+
+ struct uacpi_namespace_node *cur_scope;
+
+ // Only used if the method is serialized
+ uacpi_u8 prev_sync_level;
+};
+
+static void *call_frame_cursor(struct call_frame *frame)
+{
+ return frame->method->code + frame->code_offset;
+}
+
+static uacpi_size call_frame_code_bytes_left(struct call_frame *frame)
+{
+ return frame->method->size - frame->code_offset;
+}
+
+static uacpi_bool call_frame_has_code(struct call_frame *frame)
+{
+ return call_frame_code_bytes_left(frame) > 0;
+}
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(call_frame_array, struct call_frame, 4)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ call_frame_array, struct call_frame, static
+)
+
+static struct call_frame *call_frame_array_one_before_last(
+ struct call_frame_array *arr
+)
+{
+ uacpi_size size;
+
+ size = call_frame_array_size(arr);
+
+ if (size < 2)
+ return UACPI_NULL;
+
+ return call_frame_array_at(arr, size - 2);
+}
+
+// NOTE: Try to keep size under 2 pages
+struct execution_context {
+ uacpi_object *ret;
+ struct call_frame_array call_stack;
+ struct held_mutexes_array held_mutexes;
+
+ struct call_frame *cur_frame;
+ struct code_block *cur_block;
+ const struct uacpi_op_spec *cur_op;
+ struct op_context *prev_op_ctx;
+ struct op_context *cur_op_ctx;
+
+ uacpi_u8 sync_level;
+};
+
+#define AML_READ(ptr, offset) (*(((uacpi_u8*)(ptr)) + offset))
+
+static uacpi_status parse_nameseg(uacpi_u8 *cursor,
+ uacpi_object_name *out_name)
+{
+ if (uacpi_unlikely(!uacpi_is_valid_nameseg(cursor)))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ uacpi_memcpy(&out_name->id, cursor, 4);
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * -------------------------------------------------------------
+ * RootChar := ‘\’
+ * ParentPrefixChar := ‘^’
+ * ‘\’ := 0x5C
+ * ‘^’ := 0x5E
+ * ------------------------------------------------------------
+ * NameSeg := <leadnamechar namechar namechar namechar>
+ * NameString := <rootchar namepath> | <prefixpath namepath>
+ * PrefixPath := Nothing | <’^’ prefixpath>
+ * NamePath := NameSeg | DualNamePath | MultiNamePath | NullName
+ * DualNamePath := DualNamePrefix NameSeg NameSeg
+ * MultiNamePath := MultiNamePrefix SegCount NameSeg(SegCount)
+ */
+
+static uacpi_status name_string_to_path(
+ struct call_frame *frame, uacpi_size offset,
+ uacpi_char **out_string, uacpi_size *out_size
+)
+{
+ uacpi_size bytes_left, prefix_bytes, nameseg_bytes = 0, namesegs;
+ uacpi_char *base_cursor, *cursor;
+ uacpi_char prev_char;
+
+ bytes_left = frame->method->size - offset;
+ cursor = (uacpi_char*)frame->method->code + offset;
+ base_cursor = cursor;
+ namesegs = 0;
+
+ prefix_bytes = 0;
+ for (;;) {
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ prev_char = *cursor;
+
+ switch (prev_char) {
+ case '^':
+ case '\\':
+ prefix_bytes++;
+ cursor++;
+ bytes_left--;
+ break;
+ default:
+ break;
+ }
+
+ if (prev_char != '^')
+ break;
+ }
+
+ // At least a NullName byte is expected here
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ namesegs = 0;
+ bytes_left--;
+ switch (*cursor++)
+ {
+ case UACPI_DUAL_NAME_PREFIX:
+ namesegs = 2;
+ break;
+ case UACPI_MULTI_NAME_PREFIX:
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ namesegs = *(uacpi_u8*)cursor;
+ if (uacpi_unlikely(namesegs == 0)) {
+ uacpi_error("MultiNamePrefix but SegCount is 0\n");
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+ }
+
+ cursor++;
+ bytes_left--;
+ break;
+ case UACPI_NULL_NAME:
+ break;
+ default:
+ /*
+ * Might be an invalid byte, but assume single nameseg for now,
+ * the code below will validate it for us.
+ */
+ cursor--;
+ bytes_left++;
+ namesegs = 1;
+ break;
+ }
+
+ if (uacpi_unlikely((namesegs * 4) > bytes_left))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ if (namesegs) {
+ // 4 chars per nameseg
+ nameseg_bytes = namesegs * 4;
+
+ // dot separator for every nameseg
+ nameseg_bytes += namesegs - 1;
+ }
+
+ *out_size = nameseg_bytes + prefix_bytes + 1;
+
+ *out_string = uacpi_kernel_alloc(*out_size);
+ if (*out_string == UACPI_NULL)
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(*out_string, base_cursor, prefix_bytes);
+
+ base_cursor = *out_string;
+ base_cursor += prefix_bytes;
+
+ while (namesegs-- > 0) {
+ uacpi_memcpy(base_cursor, cursor, 4);
+ cursor += 4;
+ base_cursor += 4;
+
+ if (namesegs)
+ *base_cursor++ = '.';
+ }
+
+ *base_cursor = '\0';
+ return UACPI_STATUS_OK;
+}
+
+enum resolve_behavior {
+ RESOLVE_CREATE_LAST_NAMESEG_FAIL_IF_EXISTS,
+ RESOLVE_FAIL_IF_DOESNT_EXIST,
+};
+
+static uacpi_status resolve_name_string(
+ struct call_frame *frame,
+ enum resolve_behavior behavior,
+ struct uacpi_namespace_node **out_node
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ uacpi_u8 *cursor;
+ uacpi_size bytes_left, namesegs = 0;
+ struct uacpi_namespace_node *parent, *cur_node = frame->cur_scope;
+ uacpi_char prev_char = 0;
+ uacpi_bool just_one_nameseg = UACPI_TRUE;
+
+ bytes_left = call_frame_code_bytes_left(frame);
+ cursor = call_frame_cursor(frame);
+
+ for (;;) {
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ switch (*cursor) {
+ case '\\':
+ if (prev_char == '^')
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ cur_node = uacpi_namespace_root();
+ break;
+ case '^':
+ // Tried to go behind root
+ if (uacpi_unlikely(cur_node == uacpi_namespace_root()))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ cur_node = cur_node->parent;
+ break;
+ default:
+ break;
+ }
+
+ prev_char = *cursor;
+
+ switch (prev_char) {
+ case '^':
+ case '\\':
+ just_one_nameseg = UACPI_FALSE;
+ cursor++;
+ bytes_left--;
+ break;
+ default:
+ break;
+ }
+
+ if (prev_char != '^')
+ break;
+ }
+
+ // At least a NullName byte is expected here
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ bytes_left--;
+ switch (*cursor++)
+ {
+ case UACPI_DUAL_NAME_PREFIX:
+ namesegs = 2;
+ just_one_nameseg = UACPI_FALSE;
+ break;
+ case UACPI_MULTI_NAME_PREFIX:
+ if (uacpi_unlikely(bytes_left == 0))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ namesegs = *cursor;
+ if (uacpi_unlikely(namesegs == 0)) {
+ uacpi_error("MultiNamePrefix but SegCount is 0\n");
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+ }
+
+ cursor++;
+ bytes_left--;
+ just_one_nameseg = UACPI_FALSE;
+ break;
+ case UACPI_NULL_NAME:
+ if (behavior == RESOLVE_CREATE_LAST_NAMESEG_FAIL_IF_EXISTS ||
+ just_one_nameseg)
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ goto out;
+ default:
+ /*
+ * Might be an invalid byte, but assume single nameseg for now,
+ * the code below will validate it for us.
+ */
+ cursor--;
+ bytes_left++;
+ namesegs = 1;
+ break;
+ }
+
+ if (uacpi_unlikely((namesegs * 4) > bytes_left))
+ return UACPI_STATUS_AML_INVALID_NAMESTRING;
+
+ for (; namesegs; cursor += 4, namesegs--) {
+ uacpi_object_name name;
+
+ ret = parse_nameseg(cursor, &name);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ parent = cur_node;
+ cur_node = uacpi_namespace_node_find_sub_node(parent, name);
+
+ switch (behavior) {
+ case RESOLVE_CREATE_LAST_NAMESEG_FAIL_IF_EXISTS:
+ if (namesegs == 1) {
+ if (cur_node) {
+ cur_node = UACPI_NULL;
+ ret = UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS;
+ goto out;
+ }
+
+ // Create the node and link to parent but don't install YET
+ cur_node = uacpi_namespace_node_alloc(name);
+ if (uacpi_unlikely(cur_node == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+
+ cur_node->parent = parent;
+ }
+ break;
+ case RESOLVE_FAIL_IF_DOESNT_EXIST:
+ if (just_one_nameseg) {
+ while (!cur_node && parent != uacpi_namespace_root()) {
+ cur_node = parent;
+ parent = cur_node->parent;
+
+ cur_node = uacpi_namespace_node_find_sub_node(parent, name);
+ }
+ }
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (cur_node == UACPI_NULL) {
+ ret = UACPI_STATUS_NOT_FOUND;
+ break;
+ }
+ }
+
+out:
+ cursor += namesegs * 4;
+ frame->code_offset = cursor - frame->method->code;
+
+ if (uacpi_likely_success(ret) && behavior == RESOLVE_FAIL_IF_DOESNT_EXIST)
+ uacpi_shareable_ref(cur_node);
+
+ *out_node = cur_node;
+ return ret;
+}
+
+static uacpi_status do_install_node_item(struct call_frame *frame,
+ struct item *item)
+{
+ uacpi_status ret;
+
+ ret = uacpi_namespace_node_install(item->node->parent, item->node);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (!frame->method->named_objects_persist)
+ ret = temp_namespace_node_array_push(&frame->temp_nodes, item->node);
+
+ if (uacpi_likely_success(ret))
+ item->node = UACPI_NULL;
+
+ return ret;
+}
+
+static uacpi_u8 peek_next_op(struct call_frame *frame, uacpi_aml_op *out_op)
+{
+ uacpi_aml_op op;
+ uacpi_size bytes_left;
+ uacpi_u8 length = 0;
+ uacpi_u8 *cursor;
+ struct code_block *block;
+
+ block = code_block_array_last(&frame->code_blocks);
+ bytes_left = block->end - frame->code_offset;
+ if (bytes_left == 0)
+ return 0;
+
+ cursor = call_frame_cursor(frame);
+
+ op = AML_READ(cursor, length++);
+ if (op == UACPI_EXT_PREFIX) {
+ if (uacpi_unlikely(bytes_left < 2))
+ return 0;
+
+ op <<= 8;
+ op |= AML_READ(cursor, length++);
+ }
+
+ *out_op = op;
+ return length;
+}
+
+static uacpi_status get_op(struct execution_context *ctx)
+{
+ uacpi_aml_op op;
+ uacpi_u8 length;
+
+ length = peek_next_op(ctx->cur_frame, &op);
+ if (uacpi_unlikely(length == 0))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ ctx->cur_frame->code_offset += length;
+ g_uacpi_rt_ctx.opcodes_executed++;
+
+ ctx->cur_op = uacpi_get_op_spec(op);
+ if (uacpi_unlikely(ctx->cur_op->properties & UACPI_OP_PROPERTY_RESERVED)) {
+ uacpi_error(
+ "invalid opcode '%s' encountered in bytestream\n",
+ ctx->cur_op->name
+ );
+ return UACPI_STATUS_AML_INVALID_OPCODE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_buffer(struct execution_context *ctx)
+{
+ struct package_length *pkg;
+ uacpi_u8 *src;
+ uacpi_object *dst, *declared_size;
+ uacpi_u32 buffer_size, init_size, aml_offset;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ aml_offset = item_array_at(&op_ctx->items, 2)->immediate;
+ src = ctx->cur_frame->method->code;
+ src += aml_offset;
+
+ pkg = &item_array_at(&op_ctx->items, 0)->pkg;
+ init_size = pkg->end - aml_offset;
+
+ // TODO: do package bounds checking at parse time
+ if (uacpi_unlikely(pkg->end > ctx->cur_frame->method->size))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ declared_size = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (uacpi_unlikely(declared_size->integer > 0xE0000000)) {
+ uacpi_error(
+ "buffer is too large (%"UACPI_PRIu64"), assuming corrupted "
+ "bytestream\n", UACPI_FMT64(declared_size->integer)
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ if (uacpi_unlikely(declared_size->integer == 0)) {
+ uacpi_error("attempted to create an empty buffer\n");
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ buffer_size = declared_size->integer;
+ if (uacpi_unlikely(init_size > buffer_size)) {
+ uacpi_error(
+ "too many buffer initializers: %u (size is %u)\n",
+ init_size, buffer_size
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ dst = item_array_at(&op_ctx->items, 3)->obj;
+ dst->buffer->data = uacpi_kernel_alloc(buffer_size);
+ if (uacpi_unlikely(dst->buffer->data == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ dst->buffer->size = buffer_size;
+
+ uacpi_memcpy_zerout(dst->buffer->data, src, buffer_size, init_size);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_string(struct execution_context *ctx)
+{
+ struct call_frame *frame = ctx->cur_frame;
+ uacpi_object *obj;
+
+ uacpi_char *string;
+ uacpi_size length, max_bytes;
+
+ obj = item_array_last(&ctx->cur_op_ctx->items)->obj;
+ string = call_frame_cursor(frame);
+
+ // TODO: sanitize string for valid UTF-8
+ max_bytes = call_frame_code_bytes_left(frame);
+ length = uacpi_strnlen(string, max_bytes);
+
+ if (uacpi_unlikely((length == max_bytes) || (string[length++] != 0x00)))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ obj->buffer->text = uacpi_kernel_alloc(length);
+ if (uacpi_unlikely(obj->buffer->text == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(obj->buffer->text, string, length);
+ obj->buffer->size = length;
+ frame->code_offset += length;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_package(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_package *package;
+ uacpi_u32 num_elements, num_defined_elements, i;
+
+ /*
+ * Layout of items here:
+ * [0] -> Package length, not interesting
+ * [1] -> Immediate or integer object, depending on PackageOp/VarPackageOp
+ * [2..N-2] -> AML pc+Package element pairs
+ * [N-1] -> The resulting package object that we're constructing
+ */
+ package = item_array_last(&op_ctx->items)->obj->package;
+
+ // 1. Detect how many elements we have, do sanity checking
+ if (op_ctx->op->code == UACPI_AML_OP_VarPackageOp) {
+ uacpi_object *var_num_elements;
+
+ var_num_elements = item_array_at(&op_ctx->items, 1)->obj;
+ if (uacpi_unlikely(var_num_elements->integer > 0xE0000000)) {
+ uacpi_error(
+ "package is too large (%"UACPI_PRIu64"), assuming "
+ "corrupted bytestream\n", UACPI_FMT64(var_num_elements->integer)
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+ num_elements = var_num_elements->integer;
+ } else {
+ num_elements = item_array_at(&op_ctx->items, 1)->immediate;
+ }
+
+ num_defined_elements = (item_array_size(&op_ctx->items) - 3) / 2;
+ if (uacpi_unlikely(num_defined_elements > num_elements)) {
+ uacpi_warn(
+ "too many package initializers: %u, truncating to %u\n",
+ num_defined_elements, num_elements
+ );
+
+ num_defined_elements = num_elements;
+ }
+
+ // 2. Create every object in the package, start as uninitialized
+ if (uacpi_unlikely(!uacpi_package_fill(package, num_elements,
+ UACPI_PREALLOC_OBJECTS_YES)))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ // 3. Go through every defined object and copy it into the package
+ for (i = 0; i < num_defined_elements; ++i) {
+ uacpi_size base_pkg_index;
+ uacpi_status ret;
+ struct item *item;
+ uacpi_object *obj;
+
+ base_pkg_index = (i * 2) + 2;
+ item = item_array_at(&op_ctx->items, base_pkg_index + 1);
+ obj = item->obj;
+
+ if (obj != UACPI_NULL && obj->type == UACPI_OBJECT_REFERENCE) {
+ /*
+ * For named objects we don't actually need the object itself, but
+ * simply the path to it. Often times objects referenced by the
+ * package are not defined until later so it's not possible to
+ * resolve them. For uniformity and to follow the behavior of NT,
+ * simply convert the name string to a path string object to be
+ * resolved later when actually needed.
+ */
+ if (obj->flags == UACPI_REFERENCE_KIND_NAMED) {
+ uacpi_object_unref(obj);
+ item->obj = UACPI_NULL;
+ obj = UACPI_NULL;
+ } else {
+ obj = uacpi_unwrap_internal_reference(obj);
+ }
+ }
+
+ if (obj == UACPI_NULL) {
+ uacpi_size length;
+ uacpi_char *path;
+
+ obj = uacpi_create_object(UACPI_OBJECT_STRING);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = name_string_to_path(
+ ctx->cur_frame,
+ item_array_at(&op_ctx->items, base_pkg_index)->immediate,
+ &path, &length
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ obj->flags = UACPI_STRING_KIND_PATH;
+ obj->buffer->text = path;
+ obj->buffer->size = length;
+
+ item->obj = obj;
+ item->type = ITEM_OBJECT;
+ }
+
+ ret = uacpi_object_assign(package->objects[i], obj,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_size sizeof_int(void)
+{
+ return g_uacpi_rt_ctx.is_rev1 ? 4 : 8;
+}
+
+static uacpi_status get_object_storage(
+ uacpi_object *obj, uacpi_data_view *out_buf, uacpi_bool include_null
+)
+{
+ switch (obj->type) {
+ case UACPI_OBJECT_INTEGER:
+ out_buf->length = sizeof_int();
+ out_buf->data = &obj->integer;
+ break;
+ case UACPI_OBJECT_STRING:
+ out_buf->length = obj->buffer->size;
+ if (out_buf->length && !include_null)
+ out_buf->length--;
+
+ out_buf->text = obj->buffer->text;
+ break;
+ case UACPI_OBJECT_BUFFER:
+ if (obj->buffer->size == 0) {
+ out_buf->bytes = UACPI_NULL;
+ out_buf->length = 0;
+ break;
+ }
+
+ out_buf->length = obj->buffer->size;
+ out_buf->bytes = obj->buffer->data;
+ break;
+ case UACPI_OBJECT_REFERENCE:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ default:
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_u8 *buffer_index_cursor(uacpi_buffer_index *buf_idx)
+{
+ uacpi_u8 *out_cursor;
+
+ out_cursor = buf_idx->buffer->data;
+ out_cursor += buf_idx->idx;
+
+ return out_cursor;
+}
+
+static void write_buffer_index(uacpi_buffer_index *buf_idx,
+ uacpi_data_view *src_buf)
+{
+ uacpi_memcpy_zerout(buffer_index_cursor(buf_idx), src_buf->bytes,
+ 1, src_buf->length);
+}
+
+/*
+ * The word "implicit cast" here is only because it's called that in
+ * the specification. In reality, we just copy one buffer to another
+ * because that's what NT does.
+ */
+static uacpi_status object_assign_with_implicit_cast(
+ uacpi_object *dst, uacpi_object *src, uacpi_data_view *wtr_response
+)
+{
+ uacpi_status ret;
+ uacpi_data_view src_buf;
+
+ ret = get_object_storage(src, &src_buf, UACPI_FALSE);
+ if (uacpi_unlikely_error(ret))
+ goto out_bad_cast;
+
+ switch (dst->type) {
+ case UACPI_OBJECT_INTEGER:
+ case UACPI_OBJECT_STRING:
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_data_view dst_buf;
+
+ ret = get_object_storage(dst, &dst_buf, UACPI_FALSE);
+ if (uacpi_unlikely_error(ret))
+ goto out_bad_cast;
+
+ uacpi_memcpy_zerout(
+ dst_buf.bytes, src_buf.bytes, dst_buf.length, src_buf.length
+ );
+ break;
+ }
+
+ case UACPI_OBJECT_BUFFER_FIELD:
+ uacpi_write_buffer_field(
+ &dst->buffer_field, src_buf.bytes, src_buf.length
+ );
+ break;
+
+ case UACPI_OBJECT_FIELD_UNIT:
+ return uacpi_write_field_unit(
+ dst->field_unit, src_buf.bytes, src_buf.length,
+ wtr_response
+ );
+
+ case UACPI_OBJECT_BUFFER_INDEX:
+ write_buffer_index(&dst->buffer_index, &src_buf);
+ break;
+
+ default:
+ ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ goto out_bad_cast;
+ }
+
+ return ret;
+
+out_bad_cast:
+ uacpi_error(
+ "attempted to perform an invalid implicit cast (%s -> %s)\n",
+ uacpi_object_type_to_string(src->type),
+ uacpi_object_type_to_string(dst->type)
+ );
+ return ret;
+}
+
+enum argx_or_localx {
+ ARGX,
+ LOCALX,
+};
+
+static uacpi_status handle_arg_or_local(
+ struct execution_context *ctx,
+ uacpi_size idx, enum argx_or_localx type
+)
+{
+ uacpi_object **src;
+ struct item *dst;
+ enum uacpi_reference_kind kind;
+
+ if (type == ARGX) {
+ src = &ctx->cur_frame->args[idx];
+ kind = UACPI_REFERENCE_KIND_ARG;
+ } else {
+ src = &ctx->cur_frame->locals[idx];
+ kind = UACPI_REFERENCE_KIND_LOCAL;
+ }
+
+ if (*src == UACPI_NULL) {
+ uacpi_object *default_value;
+
+ default_value = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(default_value == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ *src = uacpi_create_internal_reference(kind, default_value);
+ if (uacpi_unlikely(*src == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_object_unref(default_value);
+ }
+
+ dst = item_array_last(&ctx->cur_op_ctx->items);
+ dst->obj = *src;
+ dst->type = ITEM_OBJECT;
+ uacpi_object_ref(dst->obj);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_local(struct execution_context *ctx)
+{
+ uacpi_size idx;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ idx = op_ctx->op->code - UACPI_AML_OP_Local0Op;
+ return handle_arg_or_local(ctx, idx, LOCALX);
+}
+
+static uacpi_status handle_arg(struct execution_context *ctx)
+{
+ uacpi_size idx;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ idx = op_ctx->op->code - UACPI_AML_OP_Arg0Op;
+ return handle_arg_or_local(ctx, idx, ARGX);
+}
+
+static uacpi_status handle_named_object(struct execution_context *ctx)
+{
+ struct uacpi_namespace_node *src;
+ struct item *dst;
+
+ src = item_array_at(&ctx->cur_op_ctx->items, 0)->node;
+ dst = item_array_at(&ctx->cur_op_ctx->items, 1);
+
+ dst->obj = src->object;
+ dst->type = ITEM_OBJECT;
+ uacpi_object_ref(dst->obj);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_alias(struct execution_context *ctx)
+{
+ uacpi_namespace_node *src, *dst;
+
+ src = item_array_at(&ctx->cur_op_ctx->items, 0)->node;
+ dst = item_array_at(&ctx->cur_op_ctx->items, 1)->node;
+
+ dst->object = src->object;
+ dst->flags = UACPI_NAMESPACE_NODE_FLAG_ALIAS;
+ uacpi_object_ref(dst->object);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_op_region(struct execution_context *ctx)
+{
+ uacpi_namespace_node *node;
+ uacpi_object *obj;
+ uacpi_operation_region *op_region;
+ uacpi_u64 region_end;
+
+ node = item_array_at(&ctx->cur_op_ctx->items, 0)->node;
+ obj = item_array_at(&ctx->cur_op_ctx->items, 4)->obj;
+ op_region = obj->op_region;
+
+ op_region->space = item_array_at(&ctx->cur_op_ctx->items, 1)->immediate;
+ op_region->offset = item_array_at(&ctx->cur_op_ctx->items, 2)->obj->integer;
+ op_region->length = item_array_at(&ctx->cur_op_ctx->items, 3)->obj->integer;
+ region_end = op_region->offset + op_region->length;
+
+ if (uacpi_unlikely(op_region->length == 0)) {
+ // Don't abort here, as long as it's never accessed we don't care
+ uacpi_warn("unusable/empty operation region %.4s\n", node->name.text);
+ } else if (uacpi_unlikely(op_region->offset > region_end)) {
+ uacpi_error(
+ "invalid operation region %.4s bounds: offset=0x%"UACPI_PRIX64
+ " length=0x%"UACPI_PRIX64"\n", node->name.text,
+ UACPI_FMT64(op_region->offset), UACPI_FMT64(op_region->length)
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ if (op_region->space == UACPI_ADDRESS_SPACE_PCC && op_region->offset > 255) {
+ uacpi_warn(
+ "invalid PCC operation region %.4s subspace %"UACPI_PRIX64"\n",
+ node->name.text, UACPI_FMT64(op_region->offset)
+ );
+ }
+
+ node->object = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_NAMED, obj
+ );
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_initialize_opregion_node(node);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status table_id_error(
+ const uacpi_char *opcode, const uacpi_char *arg,
+ uacpi_buffer *str
+)
+{
+ uacpi_error("%s: invalid %s '%s'\n", opcode, arg, str->text);
+ return UACPI_STATUS_AML_BAD_ENCODING;
+}
+
+static void report_table_id_find_error(
+ const uacpi_char *opcode, struct uacpi_table_identifiers *id,
+ uacpi_status ret
+)
+{
+ uacpi_error(
+ "%s: unable to find table '%.4s' (OEM ID '%.6s', "
+ "OEM Table ID '%.8s'): %s\n",
+ opcode, id->signature.text, id->oemid, id->oem_table_id,
+ uacpi_status_to_string(ret)
+ );
+}
+
+static uacpi_status build_table_id(
+ const uacpi_char *opcode,
+ struct uacpi_table_identifiers *out_id,
+ uacpi_buffer *signature, uacpi_buffer *oem_id,
+ uacpi_buffer *oem_table_id
+)
+{
+ if (uacpi_unlikely(signature->size != (sizeof(uacpi_object_name) + 1)))
+ return table_id_error(opcode, "SignatureString", signature);
+
+ uacpi_memcpy(out_id->signature.text, signature->text,
+ sizeof(uacpi_object_name));
+
+ if (uacpi_unlikely(oem_id->size > (sizeof(out_id->oemid) + 1)))
+ return table_id_error(opcode, "OemIDString", oem_id);
+
+ uacpi_memcpy_zerout(
+ out_id->oemid, oem_id->text,
+ sizeof(out_id->oemid), oem_id->size ? oem_id->size - 1 : 0
+ );
+
+ if (uacpi_unlikely(oem_table_id->size > (sizeof(out_id->oem_table_id) + 1)))
+ return table_id_error(opcode, "OemTableIDString", oem_table_id);
+
+ uacpi_memcpy_zerout(
+ out_id->oem_table_id, oem_table_id->text,
+ sizeof(out_id->oem_table_id),
+ oem_table_id->size ? oem_table_id->size - 1 : 0
+ );
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_data_region(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct item_array *items = &ctx->cur_op_ctx->items;
+ struct uacpi_table_identifiers table_id;
+ uacpi_table table;
+ uacpi_namespace_node *node;
+ uacpi_object *obj;
+ uacpi_operation_region *op_region;
+
+ node = item_array_at(items, 0)->node;
+
+ ret = build_table_id(
+ "DataTableRegion", &table_id,
+ item_array_at(items, 1)->obj->buffer,
+ item_array_at(items, 2)->obj->buffer,
+ item_array_at(items, 3)->obj->buffer
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_table_find(&table_id, &table);
+ if (uacpi_unlikely_error(ret)) {
+ report_table_id_find_error("DataTableRegion", &table_id, ret);
+ return ret;
+ }
+
+ obj = item_array_at(items, 4)->obj;
+ op_region = obj->op_region;
+ op_region->space = UACPI_ADDRESS_SPACE_TABLE_DATA;
+ op_region->offset = table.virt_addr;
+ op_region->length = table.hdr->length;
+ op_region->table_idx = table.index;
+
+ node->object = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_NAMED, obj
+ );
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_initialize_opregion_node(node);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_bool is_dynamic_table_load(enum uacpi_table_load_cause cause)
+{
+ return cause != UACPI_TABLE_LOAD_CAUSE_INIT;
+}
+
+static void prepare_table_load(
+ void *ptr, enum uacpi_table_load_cause cause, uacpi_control_method *in_method
+)
+{
+ struct acpi_dsdt *dsdt = ptr;
+ enum uacpi_log_level log_level = UACPI_LOG_TRACE;
+ const uacpi_char *log_prefix = "load of";
+
+ if (is_dynamic_table_load(cause)) {
+ log_prefix = cause == UACPI_TABLE_LOAD_CAUSE_HOST ?
+ "host-invoked load of" : "dynamic load of";
+ log_level = UACPI_LOG_INFO;
+ }
+
+ uacpi_log_lvl(
+ log_level, "%s "UACPI_PRI_TBL_HDR"\n",
+ log_prefix, UACPI_FMT_TBL_HDR(&dsdt->hdr)
+ );
+
+ in_method->code = dsdt->definition_block;
+ in_method->size = dsdt->hdr.length - sizeof(dsdt->hdr);
+ in_method->named_objects_persist = UACPI_TRUE;
+}
+
+static uacpi_status do_load_table(
+ uacpi_namespace_node *parent, struct acpi_sdt_hdr *tbl,
+ enum uacpi_table_load_cause cause
+)
+{
+ struct uacpi_control_method method = { 0 };
+ uacpi_status ret;
+
+ prepare_table_load(tbl, cause, &method);
+
+ ret = uacpi_execute_control_method(parent, &method, UACPI_NULL, UACPI_NULL);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (is_dynamic_table_load(cause))
+ uacpi_events_match_post_dynamic_table_load();
+
+ return ret;
+}
+
+static uacpi_status handle_load_table(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct item_array *items = &ctx->cur_op_ctx->items;
+ struct item *root_node_item;
+ struct uacpi_table_identifiers table_id;
+ uacpi_table table;
+ uacpi_buffer *root_path, *param_path;
+ uacpi_control_method *method;
+ uacpi_namespace_node *root_node, *param_node = UACPI_NULL;
+
+ /*
+ * If we already have the last true/false object loaded, this is a second
+ * invocation of this handler. For the second invocation we want to detect
+ * new AML GPE handlers that might've been loaded, as well as potentially
+ * remove the target.
+ */
+ if (item_array_size(items) == 12) {
+ uacpi_size idx;
+ struct uacpi_table tmp_table = { 0 };
+
+ idx = item_array_at(items, 2)->immediate;
+ tmp_table.index = idx;
+ uacpi_table_unref(&tmp_table);
+
+ /*
+ * If this load failed, remove the target that was provided via
+ * ParameterPathString so that it doesn't get stored to.
+ */
+ if (uacpi_unlikely(item_array_at(items, 11)->obj->integer == 0)) {
+ uacpi_object *target;
+
+ target = item_array_at(items, 3)->obj;
+ if (target != UACPI_NULL) {
+ uacpi_object_unref(target);
+ item_array_at(items, 3)->obj = UACPI_NULL;
+ }
+
+ return UACPI_STATUS_OK;
+ }
+
+ uacpi_events_match_post_dynamic_table_load();
+ return UACPI_STATUS_OK;
+ }
+
+ ret = build_table_id(
+ "LoadTable", &table_id,
+ item_array_at(items, 5)->obj->buffer,
+ item_array_at(items, 6)->obj->buffer,
+ item_array_at(items, 7)->obj->buffer
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ root_path = item_array_at(items, 8)->obj->buffer;
+ param_path = item_array_at(items, 9)->obj->buffer;
+ root_node_item = item_array_at(items, 0);
+
+ if (root_path->size > 1) {
+ ret = uacpi_namespace_node_resolve(
+ ctx->cur_frame->cur_scope, root_path->text, UACPI_SHOULD_LOCK_NO,
+ UACPI_MAY_SEARCH_ABOVE_PARENT_YES, UACPI_PERMANENT_ONLY_NO,
+ &root_node
+ );
+ if (uacpi_unlikely_error(ret)) {
+ table_id_error("LoadTable", "RootPathString", root_path);
+ if (ret == UACPI_STATUS_NOT_FOUND)
+ ret = UACPI_STATUS_AML_UNDEFINED_REFERENCE;
+ return ret;
+ }
+ } else {
+ root_node = uacpi_namespace_root();
+ }
+
+ root_node_item->node = root_node;
+ root_node_item->type = ITEM_NAMESPACE_NODE;
+ uacpi_shareable_ref(root_node);
+
+ if (param_path->size > 1) {
+ struct item *param_item;
+
+ ret = uacpi_namespace_node_resolve(
+ root_node, param_path->text, UACPI_SHOULD_LOCK_NO,
+ UACPI_MAY_SEARCH_ABOVE_PARENT_YES, UACPI_PERMANENT_ONLY_NO,
+ &param_node
+ );
+ if (uacpi_unlikely_error(ret)) {
+ table_id_error("LoadTable", "ParameterPathString", root_path);
+ if (ret == UACPI_STATUS_NOT_FOUND)
+ ret = UACPI_STATUS_AML_UNDEFINED_REFERENCE;
+ return ret;
+ }
+
+ param_item = item_array_at(items, 3);
+ param_item->obj = param_node->object;
+ uacpi_object_ref(param_item->obj);
+ param_item->type = ITEM_OBJECT;
+ }
+
+ ret = uacpi_table_find(&table_id, &table);
+ if (uacpi_unlikely_error(ret)) {
+ report_table_id_find_error("LoadTable", &table_id, ret);
+ return ret;
+ }
+ uacpi_table_mark_as_loaded(table.index);
+
+ item_array_at(items, 2)->immediate = table.index;
+ method = item_array_at(items, 1)->obj->method;
+ prepare_table_load(table.hdr, UACPI_TABLE_LOAD_CAUSE_LOAD_TABLE_OP, method);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_load(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct item_array *items = &ctx->cur_op_ctx->items;
+ uacpi_table table;
+ uacpi_control_method *method;
+ uacpi_object *src;
+ struct acpi_sdt_hdr *src_table = UACPI_NULL;
+ void *table_buffer;
+ uacpi_size declared_size;
+ uacpi_bool unmap_src = UACPI_FALSE;
+
+ /*
+ * If we already have the last true/false object loaded, this is a second
+ * invocation of this handler. For the second invocation we simply want to
+ * detect new AML GPE handlers that might've been loaded.
+ * We do this only if table load was successful though.
+ */
+ if (item_array_size(items) == 5) {
+ if (item_array_at(items, 4)->obj->integer != 0)
+ uacpi_events_match_post_dynamic_table_load();
+ return UACPI_STATUS_OK;
+ }
+
+ src = item_array_at(items, 2)->obj;
+
+ switch (src->type) {
+ case UACPI_OBJECT_OPERATION_REGION: {
+ uacpi_operation_region *op_region;
+
+ op_region = src->op_region;
+ if (uacpi_unlikely(
+ op_region->space != UACPI_ADDRESS_SPACE_SYSTEM_MEMORY
+ )) {
+ uacpi_error("Load: operation region is not SystemMemory\n");
+ goto error_out;
+ }
+
+ if (uacpi_unlikely(op_region->length < sizeof(struct acpi_sdt_hdr))) {
+ uacpi_error(
+ "Load: operation region is too small: %"UACPI_PRIu64"\n",
+ UACPI_FMT64(op_region->length)
+ );
+ goto error_out;
+ }
+
+ src_table = uacpi_kernel_map(op_region->offset, op_region->length);
+ if (uacpi_unlikely(src_table == UACPI_NULL)) {
+ uacpi_error(
+ "Load: failed to map operation region "
+ "0x%016"UACPI_PRIX64" -> 0x%016"UACPI_PRIX64"\n",
+ UACPI_FMT64(op_region->offset),
+ UACPI_FMT64(op_region->offset + op_region->length)
+ );
+ goto error_out;
+ }
+
+ unmap_src = UACPI_TRUE;
+ declared_size = op_region->length;
+ break;
+ }
+
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_buffer *buffer;
+
+ buffer = src->buffer;
+ if (buffer->size < sizeof(struct acpi_sdt_hdr)) {
+ uacpi_error(
+ "Load: buffer is too small: %zu\n",
+ buffer->size
+ );
+ goto error_out;
+ }
+
+ src_table = buffer->data;
+ declared_size = buffer->size;
+ break;
+ }
+
+ default:
+ uacpi_error(
+ "Load: invalid argument '%s', expected "
+ "Buffer/Field/OperationRegion\n",
+ uacpi_object_type_to_string(src->type)
+ );
+ goto error_out;
+ }
+
+ if (uacpi_unlikely(src_table->length > declared_size)) {
+ uacpi_error(
+ "Load: table size %u is larger than the declared size %zu\n",
+ src_table->length, declared_size
+ );
+ goto error_out;
+ }
+
+ if (uacpi_unlikely(src_table->length < sizeof(struct acpi_sdt_hdr))) {
+ uacpi_error("Load: table size %u is too small\n", src_table->length);
+ goto error_out;
+ }
+
+ table_buffer = uacpi_kernel_alloc(src_table->length);
+ if (uacpi_unlikely(table_buffer == UACPI_NULL))
+ goto error_out;
+
+ uacpi_memcpy(table_buffer, src_table, src_table->length);
+
+ if (unmap_src) {
+ uacpi_kernel_unmap(src_table, declared_size);
+ unmap_src = UACPI_FALSE;
+ }
+
+ ret = uacpi_table_install_with_origin(
+ table_buffer, UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL, &table
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free(table_buffer, src_table->length);
+
+ if (ret != UACPI_STATUS_OVERRIDDEN)
+ goto error_out;
+ }
+ uacpi_table_mark_as_loaded(table.index);
+
+ item_array_at(items, 0)->node = uacpi_namespace_root();
+
+ method = item_array_at(items, 1)->obj->method;
+ prepare_table_load(table.ptr, UACPI_TABLE_LOAD_CAUSE_LOAD_OP, method);
+
+ return UACPI_STATUS_OK;
+
+error_out:
+ if (unmap_src && src_table)
+ uacpi_kernel_unmap(src_table, declared_size);
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_execute_table(void *tbl, enum uacpi_table_load_cause cause)
+{
+ uacpi_status ret;
+
+ ret = uacpi_namespace_write_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = do_load_table(uacpi_namespace_root(), tbl, cause);
+
+ uacpi_namespace_write_unlock();
+ return ret;
+}
+
+static uacpi_u32 get_field_length(struct item *item)
+{
+ struct package_length *pkg = &item->pkg;
+ return pkg->end - pkg->begin;
+}
+
+struct field_specific_data {
+ uacpi_namespace_node *region;
+ struct uacpi_field_unit *field0;
+ struct uacpi_field_unit *field1;
+ uacpi_u64 value;
+};
+
+static uacpi_status ensure_is_a_field_unit(uacpi_namespace_node *node,
+ uacpi_field_unit **out_field)
+{
+ uacpi_object *obj;
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (obj->type != UACPI_OBJECT_FIELD_UNIT) {
+ uacpi_error(
+ "invalid argument: '%.4s' is not a field unit (%s)\n",
+ node->name.text, uacpi_object_type_to_string(obj->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ *out_field = obj->field_unit;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status ensure_is_an_op_region(uacpi_namespace_node *node,
+ uacpi_namespace_node **out_node)
+{
+ uacpi_object *obj;
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (obj->type != UACPI_OBJECT_OPERATION_REGION) {
+ uacpi_error(
+ "invalid argument: '%.4s' is not an operation region (%s)\n",
+ node->name.text, uacpi_object_type_to_string(obj->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ *out_node = node;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_field(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_namespace_node *node;
+ uacpi_object *obj, *connection_obj = UACPI_NULL;
+ struct field_specific_data field_data = { 0 };
+ uacpi_size i = 1, bit_offset = 0;
+ uacpi_u32 length, pin_offset = 0;
+
+ uacpi_u8 raw_value, access_type, lock_rule, update_rule;
+ uacpi_u8 access_attrib = 0, access_length = 0;
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_FieldOp:
+ node = item_array_at(&op_ctx->items, i++)->node;
+ ret = ensure_is_an_op_region(node, &field_data.region);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ break;
+
+ case UACPI_AML_OP_BankFieldOp:
+ node = item_array_at(&op_ctx->items, i++)->node;
+ ret = ensure_is_an_op_region(node, &field_data.region);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ node = item_array_at(&op_ctx->items, i++)->node;
+ ret = ensure_is_a_field_unit(node, &field_data.field0);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ field_data.value = item_array_at(&op_ctx->items, i++)->obj->integer;
+ break;
+
+ case UACPI_AML_OP_IndexFieldOp:
+ node = item_array_at(&op_ctx->items, i++)->node;
+ ret = ensure_is_a_field_unit(node, &field_data.field0);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ node = item_array_at(&op_ctx->items, i++)->node;
+ ret = ensure_is_a_field_unit(node, &field_data.field1);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ break;
+
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ /*
+ * ByteData
+ * bit 0-3: AccessType
+ * 0 AnyAcc
+ * 1 ByteAcc
+ * 2 WordAcc
+ * 3 DWordAcc
+ * 4 QWordAcc
+ * 5 BufferAcc
+ * 6 Reserved
+ * 7-15 Reserved
+ * bit 4: LockRule
+ * 0 NoLock
+ * 1 Lock
+ * bit 5-6: UpdateRule
+ * 0 Preserve
+ * 1 WriteAsOnes
+ * 2 WriteAsZeros
+ * bit 7: Reserved (must be 0)
+ */
+ raw_value = item_array_at(&op_ctx->items, i++)->immediate;
+ access_type = (raw_value >> 0) & 0xF;
+ lock_rule = (raw_value >> 4) & 0x1;
+ update_rule = (raw_value >> 5) & 0x3;
+
+ while (i < item_array_size(&op_ctx->items)) {
+ struct item *item;
+ item = item_array_at(&op_ctx->items, i++);
+
+ // An actual field object
+ if (item->type == ITEM_NAMESPACE_NODE) {
+ uacpi_field_unit *field;
+
+ length = get_field_length(item_array_at(&op_ctx->items, i++));
+ node = item->node;
+
+ obj = item_array_at(&op_ctx->items, i++)->obj;
+ field = obj->field_unit;
+
+ field->update_rule = update_rule;
+ field->lock_rule = lock_rule;
+ field->attributes = access_attrib;
+ field->access_length = access_length;
+
+ /*
+ * 0 AnyAcc
+ * 1 ByteAcc
+ * 2 WordAcc
+ * 3 DWordAcc
+ * 4 QWordAcc
+ * 5 BufferAcc
+ * 6 Reserved
+ * 7-15 Reserved
+ */
+ switch (access_type) {
+ case 0:
+ // TODO: optimize to calculate best access strategy
+ UACPI_FALLTHROUGH;
+ case 1:
+ case 5:
+ field->access_width_bytes = 1;
+ break;
+ case 2:
+ field->access_width_bytes = 2;
+ break;
+ case 3:
+ field->access_width_bytes = 4;
+ break;
+ case 4:
+ field->access_width_bytes = 8;
+ break;
+ default:
+ uacpi_error("invalid field '%.4s' access type %d\n",
+ node->name.text, access_type);
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ field->bit_length = length;
+ field->pin_offset = pin_offset;
+
+ // FIXME: overflow, OOB, etc checks
+ field->byte_offset = UACPI_ALIGN_DOWN(
+ bit_offset / 8,
+ field->access_width_bytes,
+ uacpi_u32
+ );
+
+ field->bit_offset_within_first_byte = bit_offset;
+ field->bit_offset_within_first_byte =
+ bit_offset & ((field->access_width_bytes * 8) - 1);
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_FieldOp:
+ field->region = field_data.region;
+ uacpi_shareable_ref(field->region);
+
+ field->kind = UACPI_FIELD_UNIT_KIND_NORMAL;
+ break;
+
+ case UACPI_AML_OP_BankFieldOp:
+ field->bank_region = field_data.region;
+ uacpi_shareable_ref(field->bank_region);
+
+ field->bank_selection = field_data.field0;
+ uacpi_shareable_ref(field->bank_selection);
+
+ field->bank_value = field_data.value;
+ field->kind = UACPI_FIELD_UNIT_KIND_BANK;
+ break;
+
+ case UACPI_AML_OP_IndexFieldOp:
+ field->index = field_data.field0;
+ uacpi_shareable_ref(field->index);
+
+ field->data = field_data.field1;
+ uacpi_shareable_ref(field->data);
+
+ field->kind = UACPI_FIELD_UNIT_KIND_INDEX;
+ break;
+
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ field->connection = connection_obj;
+ if (field->connection)
+ uacpi_object_ref(field->connection);
+
+ node->object = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_NAMED, obj
+ );
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = do_install_node_item(ctx->cur_frame, item);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ bit_offset += length;
+ pin_offset += length;
+ continue;
+ }
+
+ // All other stuff
+ switch ((int)item->immediate) {
+ // ReservedField := 0x00 PkgLength
+ case 0x00:
+ length = get_field_length(item_array_at(&op_ctx->items, i++));
+ bit_offset += length;
+ pin_offset += length;
+ break;
+
+ // AccessField := 0x01 AccessType AccessAttrib
+ // ExtendedAccessField := 0x03 AccessType ExtendedAccessAttrib AccessLength
+ case 0x01:
+ case 0x03:
+ raw_value = item_array_at(&op_ctx->items, i++)->immediate;
+
+ access_type = raw_value & 0xF;
+ access_attrib = (raw_value >> 6) & 0x3;
+
+ raw_value = item_array_at(&op_ctx->items, i++)->immediate;
+
+ /*
+ * Bits 7:6
+ * 0 = AccessAttrib = Normal Access Attributes
+ * 1 = AccessAttrib = AttribBytes (x)
+ * 2 = AccessAttrib = AttribRawBytes (x)
+ * 3 = AccessAttrib = AttribRawProcessBytes (x)
+ * x is encoded as bits 0:7 of the AccessAttrib byte.
+ */
+ if (access_attrib) {
+ switch (access_attrib) {
+ case 1:
+ access_attrib = UACPI_ACCESS_ATTRIBUTE_BYTES;
+ break;
+ case 2:
+ access_attrib = UACPI_ACCESS_ATTRIBUTE_RAW_BYTES;
+ break;
+ case 3:
+ access_attrib = UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES;
+ break;
+ }
+
+ access_length = raw_value;
+ } else { // Normal access attributes
+ access_attrib = raw_value;
+ }
+
+ if (item->immediate == 3)
+ access_length = item_array_at(&op_ctx->items, i++)->immediate;
+ break;
+
+ // ConnectField := <0x02 NameString> | <0x02 BufferData>
+ case 0x02:
+ connection_obj = item_array_at(&op_ctx->items, i++)->obj;
+ pin_offset = 0;
+ break;
+
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static void truncate_number_if_needed(uacpi_object *obj)
+{
+ if (!g_uacpi_rt_ctx.is_rev1)
+ return;
+
+ obj->integer &= 0xFFFFFFFF;
+}
+
+static uacpi_u64 ones(void)
+{
+ return g_uacpi_rt_ctx.is_rev1 ? 0xFFFFFFFF : 0xFFFFFFFFFFFFFFFF;
+}
+
+static uacpi_status method_get_ret_target(struct execution_context *ctx,
+ uacpi_object **out_operand)
+{
+ uacpi_size depth;
+
+ // Check if we're targeting the previous call frame
+ depth = call_frame_array_size(&ctx->call_stack);
+ if (depth > 1) {
+ struct op_context *op_ctx;
+ struct call_frame *frame;
+
+ frame = call_frame_array_at(&ctx->call_stack, depth - 2);
+ depth = op_context_array_size(&frame->pending_ops);
+
+ // Ok, no one wants the return value at call site. Discard it.
+ if (!depth) {
+ *out_operand = UACPI_NULL;
+ return UACPI_STATUS_OK;
+ }
+
+ op_ctx = op_context_array_at(&frame->pending_ops, depth - 1);
+
+ /*
+ * Prevent the table being dynamically loaded from attempting to return
+ * a value to the caller. This is unlikely to be ever encountered in the
+ * wild, but we should still guard against the possibility.
+ */
+ if (uacpi_unlikely(op_ctx->op->code == UACPI_AML_OP_LoadOp ||
+ op_ctx->op->code == UACPI_AML_OP_LoadTableOp)) {
+ *out_operand = UACPI_NULL;
+ return UACPI_STATUS_OK;
+ }
+
+ *out_operand = item_array_last(&op_ctx->items)->obj;
+ return UACPI_STATUS_OK;
+ }
+
+ return UACPI_STATUS_NOT_FOUND;
+}
+
+static uacpi_status method_get_ret_object(struct execution_context *ctx,
+ uacpi_object **out_obj)
+{
+ uacpi_status ret;
+
+ ret = method_get_ret_target(ctx, out_obj);
+ if (ret == UACPI_STATUS_NOT_FOUND) {
+ *out_obj = ctx->ret;
+ return UACPI_STATUS_OK;
+ }
+ if (ret != UACPI_STATUS_OK || *out_obj == UACPI_NULL)
+ return ret;
+
+ *out_obj = uacpi_unwrap_internal_reference(*out_obj);
+ return UACPI_STATUS_OK;
+}
+
+static struct code_block *find_last_block(struct code_block_array *blocks,
+ enum code_block_type type)
+{
+ uacpi_size i;
+
+ i = code_block_array_size(blocks);
+ while (i-- > 0) {
+ struct code_block *block;
+
+ block = code_block_array_at(blocks, i);
+ if (block->type == type)
+ return block;
+ }
+
+ return UACPI_NULL;
+}
+
+static void update_scope(struct call_frame *frame)
+{
+ struct code_block *block;
+
+ block = find_last_block(&frame->code_blocks, CODE_BLOCK_SCOPE);
+ if (block == UACPI_NULL) {
+ frame->cur_scope = uacpi_namespace_root();
+ return;
+ }
+
+ frame->cur_scope = block->node;
+}
+
+static uacpi_status begin_block_execution(struct execution_context *ctx)
+{
+ struct call_frame *cur_frame = ctx->cur_frame;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct package_length *pkg;
+ struct code_block *block;
+
+ block = code_block_array_alloc(&cur_frame->code_blocks);
+ if (uacpi_unlikely(block == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ pkg = &item_array_at(&op_ctx->items, 0)->pkg;
+
+ // Disarm the tracked package so that we don't skip the Scope
+ op_ctx->tracked_pkg_idx = 0;
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_IfOp:
+ block->type = CODE_BLOCK_IF;
+ break;
+ case UACPI_AML_OP_ElseOp:
+ block->type = CODE_BLOCK_ELSE;
+ break;
+ case UACPI_AML_OP_WhileOp:
+ block->type = CODE_BLOCK_WHILE;
+
+ if (pkg->begin == cur_frame->prev_while_code_offset) {
+ uacpi_u64 cur_ticks;
+
+ cur_ticks = uacpi_kernel_get_nanoseconds_since_boot();
+
+ if (uacpi_unlikely(cur_ticks > block->expiration_point)) {
+ uacpi_error("loop time out after running for %u seconds\n",
+ g_uacpi_rt_ctx.loop_timeout_seconds);
+ code_block_array_pop(&cur_frame->code_blocks);
+ return UACPI_STATUS_AML_LOOP_TIMEOUT;
+ }
+
+ block->expiration_point = cur_frame->prev_while_expiration;
+ } else {
+ /*
+ * Calculate the expiration point for this loop.
+ * If a loop is executed past this point, it will get aborted.
+ */
+ block->expiration_point = uacpi_kernel_get_nanoseconds_since_boot();
+ block->expiration_point +=
+ g_uacpi_rt_ctx.loop_timeout_seconds * UACPI_NANOSECONDS_PER_SEC;
+ }
+ break;
+ case UACPI_AML_OP_ScopeOp:
+ case UACPI_AML_OP_DeviceOp:
+ case UACPI_AML_OP_ProcessorOp:
+ case UACPI_AML_OP_PowerResOp:
+ case UACPI_AML_OP_ThermalZoneOp:
+ block->type = CODE_BLOCK_SCOPE;
+ block->node = item_array_at(&op_ctx->items, 1)->node;
+ break;
+ default:
+ code_block_array_pop(&cur_frame->code_blocks);
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ // -1 because we want to re-evaluate at the start of the op next time
+ block->begin = pkg->begin - 1;
+ block->end = pkg->end;
+ ctx->cur_block = block;
+
+ cur_frame->last_while = find_last_block(&cur_frame->code_blocks,
+ CODE_BLOCK_WHILE);
+ update_scope(cur_frame);
+ return UACPI_STATUS_OK;
+}
+
+static void frame_reset_post_end_block(struct execution_context *ctx,
+ enum code_block_type type)
+{
+ struct call_frame *frame = ctx->cur_frame;
+
+ if (type == CODE_BLOCK_WHILE) {
+ struct code_block *block = ctx->cur_block;
+
+ // + 1 here to skip the WhileOp and get to the PkgLength
+ frame->prev_while_code_offset = block->begin + 1;
+ frame->prev_while_expiration = block->expiration_point;
+ }
+
+ code_block_array_pop(&frame->code_blocks);
+ ctx->cur_block = code_block_array_last(&frame->code_blocks);
+
+ if (type == CODE_BLOCK_WHILE) {
+ frame->last_while = find_last_block(&frame->code_blocks, type);
+ } else if (type == CODE_BLOCK_SCOPE) {
+ update_scope(frame);
+ }
+}
+
+static void debug_store_no_recurse(const uacpi_char *prefix, uacpi_object *src)
+{
+ switch (src->type) {
+ case UACPI_OBJECT_UNINITIALIZED:
+ uacpi_trace("%s Uninitialized\n", prefix);
+ break;
+ case UACPI_OBJECT_STRING:
+ uacpi_trace("%s String => \"%s\"\n", prefix, src->buffer->text);
+ break;
+ case UACPI_OBJECT_INTEGER:
+ if (g_uacpi_rt_ctx.is_rev1) {
+ uacpi_trace(
+ "%s Integer => 0x%08X\n", prefix, (uacpi_u32)src->integer
+ );
+ } else {
+ uacpi_trace(
+ "%s Integer => 0x%016"UACPI_PRIX64"\n", prefix,
+ UACPI_FMT64(src->integer)
+ );
+ }
+ break;
+ case UACPI_OBJECT_REFERENCE:
+ uacpi_trace("%s Reference @%p => %p\n", prefix, src, src->inner_object);
+ break;
+ case UACPI_OBJECT_PACKAGE:
+ uacpi_trace(
+ "%s Package @%p (%p) (%zu elements)\n",
+ prefix, src, src->package, src->package->count
+ );
+ break;
+ case UACPI_OBJECT_BUFFER:
+ uacpi_trace(
+ "%s Buffer @%p (%p) (%zu bytes)\n",
+ prefix, src, src->buffer, src->buffer->size
+ );
+ break;
+ case UACPI_OBJECT_OPERATION_REGION:
+ uacpi_trace(
+ "%s OperationRegion (ASID %d) 0x%016"UACPI_PRIX64
+ " -> 0x%016"UACPI_PRIX64"\n", prefix,
+ src->op_region->space, UACPI_FMT64(src->op_region->offset),
+ UACPI_FMT64(src->op_region->offset + src->op_region->length)
+ );
+ break;
+ case UACPI_OBJECT_POWER_RESOURCE:
+ uacpi_trace(
+ "%s Power Resource %d %d\n",
+ prefix, src->power_resource.system_level,
+ src->power_resource.resource_order
+ );
+ break;
+ case UACPI_OBJECT_PROCESSOR:
+ uacpi_trace(
+ "%s Processor[%d] 0x%08X (%d)\n",
+ prefix, src->processor->id, src->processor->block_address,
+ src->processor->block_length
+ );
+ break;
+ case UACPI_OBJECT_BUFFER_INDEX:
+ uacpi_trace(
+ "%s Buffer Index %p[%zu] => 0x%02X\n",
+ prefix, src->buffer_index.buffer->data, src->buffer_index.idx,
+ *buffer_index_cursor(&src->buffer_index)
+ );
+ break;
+ case UACPI_OBJECT_MUTEX:
+ uacpi_trace(
+ "%s Mutex @%p (%p => %p) sync level %d\n",
+ prefix, src, src->mutex, src->mutex->handle,
+ src->mutex->sync_level
+ );
+ break;
+ case UACPI_OBJECT_METHOD:
+ uacpi_trace("%s Method @%p (%p)\n", prefix, src, src->method);
+ break;
+ default:
+ uacpi_trace(
+ "%s %s @%p\n",
+ prefix, uacpi_object_type_to_string(src->type), src
+ );
+ }
+}
+
+static uacpi_status debug_store(uacpi_object *src)
+{
+ /*
+ * Don't bother running the body if current log level is not set to trace.
+ * All DebugOp logging is done as TRACE exclusively.
+ */
+ if (!uacpi_should_log(UACPI_LOG_TRACE))
+ return UACPI_STATUS_OK;
+
+ src = uacpi_unwrap_internal_reference(src);
+
+ debug_store_no_recurse("[AML DEBUG]", src);
+
+ if (src->type == UACPI_OBJECT_PACKAGE) {
+ uacpi_package *pkg = src->package;
+ uacpi_size i;
+
+ for (i = 0; i < pkg->count; ++i) {
+ uacpi_object *obj = pkg->objects[i];
+ if (obj->type == UACPI_OBJECT_REFERENCE &&
+ obj->flags == UACPI_REFERENCE_KIND_PKG_INDEX)
+ obj = obj->inner_object;
+
+ debug_store_no_recurse("Element:", obj);
+ }
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * NOTE: this function returns the parent object
+ */
+static uacpi_object *reference_unwind(uacpi_object *obj)
+{
+ uacpi_object *parent = obj;
+
+ while (obj) {
+ if (obj->type != UACPI_OBJECT_REFERENCE)
+ return parent;
+
+ parent = obj;
+ obj = parent->inner_object;
+ }
+
+ // This should be unreachable
+ return UACPI_NULL;
+}
+
+static uacpi_iteration_decision opregion_try_detach_from_parent(
+ void *user, uacpi_namespace_node *node, uacpi_u32 node_depth
+)
+{
+ uacpi_object *target_object = user;
+ UACPI_UNUSED(node_depth);
+
+ if (node->object == target_object) {
+ uacpi_opregion_uninstall_handler(node);
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+static void object_replace_child(uacpi_object *parent, uacpi_object *new_child)
+{
+ if (parent->flags == UACPI_REFERENCE_KIND_NAMED &&
+ uacpi_object_is(parent->inner_object, UACPI_OBJECT_OPERATION_REGION)) {
+
+ /*
+ * We're doing a CopyObject or similar to a namespace node that is an
+ * operation region. Try to find the parent node and manually detach
+ * the handler.
+ */
+ opregion_try_detach_from_parent(parent, uacpi_namespace_root(), 0);
+ uacpi_namespace_do_for_each_child(
+ uacpi_namespace_root(), opregion_try_detach_from_parent, UACPI_NULL,
+ UACPI_OBJECT_OPERATION_REGION_BIT, UACPI_MAX_DEPTH_ANY,
+ UACPI_SHOULD_LOCK_NO, UACPI_PERMANENT_ONLY_NO, parent
+ );
+ }
+
+ uacpi_object_detach_child(parent);
+ uacpi_object_attach_child(parent, new_child);
+}
+
+/*
+ * Breakdown of what happens here:
+ *
+ * CopyObject(..., Obj) where Obj is:
+ * 1. LocalX -> Overwrite LocalX.
+ * 2. NAME -> Overwrite NAME.
+ * 3. ArgX -> Overwrite ArgX unless ArgX is a reference, in that case
+ * overwrite the referenced object.
+ * 4. RefOf -> Not allowed here.
+ * 5. Index -> Overwrite Object stored at the index.
+ */
+ static uacpi_status copy_object_to_reference(uacpi_object *dst,
+ uacpi_object *src)
+{
+ uacpi_status ret;
+ uacpi_object *src_obj, *new_obj;
+
+ switch (dst->flags) {
+ case UACPI_REFERENCE_KIND_ARG: {
+ uacpi_object *referenced_obj;
+
+ referenced_obj = uacpi_unwrap_internal_reference(dst);
+ if (referenced_obj->type == UACPI_OBJECT_REFERENCE) {
+ dst = reference_unwind(referenced_obj);
+ break;
+ }
+
+ UACPI_FALLTHROUGH;
+ }
+ case UACPI_REFERENCE_KIND_LOCAL:
+ case UACPI_REFERENCE_KIND_PKG_INDEX:
+ case UACPI_REFERENCE_KIND_NAMED:
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ src_obj = uacpi_unwrap_internal_reference(src);
+
+ new_obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(new_obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = uacpi_object_assign(new_obj, src_obj,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ object_replace_child(dst, new_obj);
+ uacpi_object_unref(new_obj);
+
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * if Store(..., Obj) where Obj is:
+ * 1. LocalX/Index -> OVERWRITE unless the object is a reference, in that
+ * case store to the referenced object _with_ implicit
+ * cast.
+ * 2. ArgX -> OVERWRITE unless the object is a reference, in that
+ * case OVERWRITE the referenced object.
+ * 3. NAME -> Store with implicit cast.
+ * 4. RefOf -> Not allowed here.
+ */
+static uacpi_status store_to_reference(
+ uacpi_object *dst, uacpi_object *src, uacpi_data_view *wtr_response
+)
+{
+ uacpi_object *src_obj;
+ uacpi_bool overwrite = UACPI_FALSE;
+
+ switch (dst->flags) {
+ case UACPI_REFERENCE_KIND_LOCAL:
+ case UACPI_REFERENCE_KIND_ARG:
+ case UACPI_REFERENCE_KIND_PKG_INDEX: {
+ uacpi_object *referenced_obj;
+
+ if (dst->flags == UACPI_REFERENCE_KIND_PKG_INDEX)
+ referenced_obj = dst->inner_object;
+ else
+ referenced_obj = uacpi_unwrap_internal_reference(dst);
+
+ if (referenced_obj->type == UACPI_OBJECT_REFERENCE) {
+ overwrite = dst->flags == UACPI_REFERENCE_KIND_ARG;
+ dst = reference_unwind(referenced_obj);
+ break;
+ }
+
+ overwrite = UACPI_TRUE;
+ break;
+ }
+ case UACPI_REFERENCE_KIND_NAMED:
+ dst = reference_unwind(dst);
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ src_obj = uacpi_unwrap_internal_reference(src);
+ overwrite |= dst->inner_object->type == UACPI_OBJECT_UNINITIALIZED;
+
+ if (overwrite) {
+ uacpi_status ret;
+ uacpi_object *new_obj;
+
+ new_obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(new_obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = uacpi_object_assign(new_obj, src_obj,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_object_unref(new_obj);
+ return ret;
+ }
+
+ object_replace_child(dst, new_obj);
+ uacpi_object_unref(new_obj);
+ return UACPI_STATUS_OK;
+ }
+
+ return object_assign_with_implicit_cast(
+ dst->inner_object, src_obj, wtr_response
+ );
+}
+
+static uacpi_status handle_ref_or_deref_of(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *dst, *src;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+
+ if (op_ctx->op->code == UACPI_AML_OP_CondRefOfOp)
+ dst = item_array_at(&op_ctx->items, 2)->obj;
+ else
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (op_ctx->op->code == UACPI_AML_OP_DerefOfOp) {
+ uacpi_bool was_a_reference = UACPI_FALSE;
+
+ if (src->type == UACPI_OBJECT_REFERENCE) {
+ was_a_reference = UACPI_TRUE;
+
+ /*
+ * Explicit dereferencing [DerefOf] behavior:
+ * Simply grabs the bottom-most object that is not a reference.
+ * This mimics the behavior of NT Acpi.sys: any DerfOf fetches
+ * the bottom-most reference. Note that this is different from
+ * ACPICA where DerefOf dereferences one level.
+ */
+ src = reference_unwind(src)->inner_object;
+ }
+
+ if (src->type == UACPI_OBJECT_BUFFER_INDEX) {
+ uacpi_buffer_index *buf_idx = &src->buffer_index;
+
+ dst->type = UACPI_OBJECT_INTEGER;
+ uacpi_memcpy_zerout(
+ &dst->integer, buffer_index_cursor(buf_idx),
+ sizeof(dst->integer), 1
+ );
+ return UACPI_STATUS_OK;
+ }
+
+ if (!was_a_reference) {
+ uacpi_error(
+ "invalid DerefOf argument: %s, expected a reference\n",
+ uacpi_object_type_to_string(src->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return uacpi_object_assign(dst, src,
+ UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY);
+ }
+
+ dst->type = UACPI_OBJECT_REFERENCE;
+ dst->inner_object = src;
+ uacpi_object_ref(src);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status do_binary_math(
+ uacpi_object *arg0, uacpi_object *arg1,
+ uacpi_object *tgt0, uacpi_object *tgt1,
+ uacpi_aml_op op
+)
+{
+ uacpi_u64 lhs, rhs, res;
+ uacpi_bool should_negate = UACPI_FALSE;
+
+ lhs = arg0->integer;
+ rhs = arg1->integer;
+
+ switch (op)
+ {
+ case UACPI_AML_OP_AddOp:
+ res = lhs + rhs;
+ break;
+ case UACPI_AML_OP_SubtractOp:
+ res = lhs - rhs;
+ break;
+ case UACPI_AML_OP_MultiplyOp:
+ res = lhs * rhs;
+ break;
+ case UACPI_AML_OP_ShiftLeftOp:
+ case UACPI_AML_OP_ShiftRightOp:
+ if (rhs <= (g_uacpi_rt_ctx.is_rev1 ? 31 : 63)) {
+ if (op == UACPI_AML_OP_ShiftLeftOp)
+ res = lhs << rhs;
+ else
+ res = lhs >> rhs;
+ } else {
+ res = 0;
+ }
+ break;
+ case UACPI_AML_OP_NandOp:
+ should_negate = UACPI_TRUE;
+ UACPI_FALLTHROUGH;
+ case UACPI_AML_OP_AndOp:
+ res = rhs & lhs;
+ break;
+ case UACPI_AML_OP_NorOp:
+ should_negate = UACPI_TRUE;
+ UACPI_FALLTHROUGH;
+ case UACPI_AML_OP_OrOp:
+ res = rhs | lhs;
+ break;
+ case UACPI_AML_OP_XorOp:
+ res = rhs ^ lhs;
+ break;
+ case UACPI_AML_OP_DivideOp:
+ if (uacpi_unlikely(rhs == 0)) {
+ uacpi_error("attempted to divide by zero\n");
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+ tgt1->integer = lhs / rhs;
+ res = lhs % rhs;
+ break;
+ case UACPI_AML_OP_ModOp:
+ if (uacpi_unlikely(rhs == 0)) {
+ uacpi_error("attempted to calculate modulo of zero\n");
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+ res = lhs % rhs;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (should_negate)
+ res = ~res;
+
+ tgt0->integer = res;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_binary_math(struct execution_context *ctx)
+{
+ uacpi_object *arg0, *arg1, *tgt0, *tgt1;
+ struct item_array *items = &ctx->cur_op_ctx->items;
+ uacpi_aml_op op = ctx->cur_op_ctx->op->code;
+
+ arg0 = item_array_at(items, 0)->obj;
+ arg1 = item_array_at(items, 1)->obj;
+
+ if (op == UACPI_AML_OP_DivideOp) {
+ tgt0 = item_array_at(items, 4)->obj;
+ tgt1 = item_array_at(items, 5)->obj;
+ } else {
+ tgt0 = item_array_at(items, 3)->obj;
+ tgt1 = UACPI_NULL;
+ }
+
+ return do_binary_math(arg0, arg1, tgt0, tgt1, op);
+}
+
+static uacpi_status handle_unary_math(struct execution_context *ctx)
+{
+ uacpi_object *arg, *tgt;
+ struct item_array *items = &ctx->cur_op_ctx->items;
+ uacpi_aml_op op = ctx->cur_op_ctx->op->code;
+
+ arg = item_array_at(items, 0)->obj;
+ tgt = item_array_at(items, 2)->obj;
+
+ switch (op) {
+ case UACPI_AML_OP_NotOp:
+ tgt->integer = ~arg->integer;
+ truncate_number_if_needed(tgt);
+ break;
+ case UACPI_AML_OP_FindSetRightBitOp:
+ tgt->integer = uacpi_bit_scan_forward(arg->integer);
+ break;
+ case UACPI_AML_OP_FindSetLeftBitOp:
+ tgt->integer = uacpi_bit_scan_backward(arg->integer);
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status ensure_valid_idx(uacpi_object *obj, uacpi_size idx,
+ uacpi_size src_size)
+{
+ if (uacpi_likely(idx < src_size))
+ return UACPI_STATUS_OK;
+
+ uacpi_error(
+ "invalid index %zu, %s@%p has %zu elements\n",
+ idx, uacpi_object_type_to_string(obj->type), obj, src_size
+ );
+ return UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX;
+}
+
+static uacpi_status handle_index(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src;
+ struct item *dst;
+ uacpi_size idx;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ idx = item_array_at(&op_ctx->items, 1)->obj->integer;
+ dst = item_array_at(&op_ctx->items, 3);
+
+ switch (src->type) {
+ case UACPI_OBJECT_BUFFER:
+ case UACPI_OBJECT_STRING: {
+ uacpi_buffer_index *buf_idx;
+ uacpi_data_view buf;
+ get_object_storage(src, &buf, UACPI_FALSE);
+
+ ret = ensure_valid_idx(src, idx, buf.length);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ dst->type = ITEM_OBJECT;
+ dst->obj = uacpi_create_object(UACPI_OBJECT_BUFFER_INDEX);
+ if (uacpi_unlikely(dst->obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ buf_idx = &dst->obj->buffer_index;
+ buf_idx->idx = idx;
+ buf_idx->buffer = src->buffer;
+ uacpi_shareable_ref(buf_idx->buffer);
+
+ break;
+ }
+ case UACPI_OBJECT_PACKAGE: {
+ uacpi_package *pkg = src->package;
+ uacpi_object *obj;
+
+ ret = ensure_valid_idx(src, idx, pkg->count);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ /*
+ * Lazily transform the package element into an internal reference
+ * to itself of type PKG_INDEX. This is needed to support stuff like
+ * CopyObject(..., Index(pkg, X)) where the new object must be
+ * propagated to anyone else with a currently alive index object.
+ *
+ * Sidenote: Yes, IndexOp is not a SimpleName, so technically it is
+ * illegal to CopyObject to it. However, yet again we fall
+ * victim to the NT ACPI driver implementation, which allows
+ * it just fine.
+ */
+ obj = pkg->objects[idx];
+ if (obj->type != UACPI_OBJECT_REFERENCE ||
+ obj->flags != UACPI_REFERENCE_KIND_PKG_INDEX) {
+
+ obj = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_PKG_INDEX, obj
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ pkg->objects[idx] = obj;
+ uacpi_object_unref(obj->inner_object);
+ }
+
+ dst->obj = obj;
+ dst->type = ITEM_OBJECT;
+ uacpi_object_ref(dst->obj);
+ break;
+ }
+ default:
+ uacpi_error(
+ "invalid argument for Index: %s, "
+ "expected String/Buffer/Package\n",
+ uacpi_object_type_to_string(src->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_u64 object_to_integer(const uacpi_object *obj,
+ uacpi_size max_buffer_bytes)
+{
+ uacpi_u64 dst;
+
+ switch (obj->type) {
+ case UACPI_OBJECT_INTEGER:
+ dst = obj->integer;
+ break;
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_size bytes;
+ bytes = UACPI_MIN(max_buffer_bytes, obj->buffer->size);
+ uacpi_memcpy_zerout(&dst, obj->buffer->data, sizeof(dst), bytes);
+ break;
+ }
+ case UACPI_OBJECT_STRING:
+ uacpi_string_to_integer(
+ obj->buffer->text, obj->buffer->size, UACPI_BASE_AUTO, &dst
+ );
+ break;
+ default:
+ dst = 0;
+ break;
+ }
+
+ return dst;
+}
+
+static uacpi_status integer_to_string(
+ uacpi_u64 integer, uacpi_buffer *str, uacpi_bool is_hex
+)
+{
+ int repr_len;
+ uacpi_char int_buf[21];
+ uacpi_size final_size;
+
+ repr_len = uacpi_snprintf(
+ int_buf, sizeof(int_buf),
+ is_hex ? "%"UACPI_PRIX64 : "%"UACPI_PRIu64,
+ UACPI_FMT64(integer)
+ );
+ if (uacpi_unlikely(repr_len < 0))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ // 0x prefix + repr + \0
+ final_size = (is_hex ? 2 : 0) + repr_len + 1;
+
+ str->data = uacpi_kernel_alloc(final_size);
+ if (uacpi_unlikely(str->data == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ if (is_hex) {
+ str->text[0] = '0';
+ str->text[1] = 'x';
+ }
+ uacpi_memcpy(str->text + (is_hex ? 2 : 0), int_buf, repr_len + 1);
+ str->size = final_size;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status buffer_to_string(
+ uacpi_buffer *buf, uacpi_buffer *str, uacpi_bool is_hex
+)
+{
+ int repr_len;
+ uacpi_char int_buf[5];
+ uacpi_size i, final_size;
+ uacpi_char *cursor;
+
+ if (is_hex) {
+ final_size = 4 * buf->size;
+ } else {
+ final_size = 0;
+
+ for (i = 0; i < buf->size; ++i) {
+ uacpi_u8 value = ((uacpi_u8*)buf->data)[i];
+
+ if (value < 10)
+ final_size += 1;
+ else if (value < 100)
+ final_size += 2;
+ else
+ final_size += 3;
+ }
+ }
+
+ // Comma for every value but one
+ final_size += buf->size - 1;
+
+ // Null terminator
+ final_size += 1;
+
+ str->data = uacpi_kernel_alloc(final_size);
+ if (uacpi_unlikely(str->data == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ cursor = str->data;
+
+ for (i = 0; i < buf->size; ++i) {
+ repr_len = uacpi_snprintf(
+ int_buf, sizeof(int_buf),
+ is_hex ? "0x%02X" : "%d",
+ ((uacpi_u8*)buf->data)[i]
+ );
+ if (uacpi_unlikely(repr_len < 0)) {
+ uacpi_free(str->data, final_size);
+ str->data = UACPI_NULL;
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ uacpi_memcpy(cursor, int_buf, repr_len + 1);
+ cursor += repr_len;
+
+ if (i != buf->size - 1)
+ *cursor++ = ',';
+ }
+
+ str->size = final_size;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status do_make_empty_object(uacpi_buffer *buf,
+ uacpi_bool is_string)
+{
+ buf->text = uacpi_kernel_alloc_zeroed(sizeof(uacpi_char));
+ if (uacpi_unlikely(buf->text == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ if (is_string)
+ buf->size = sizeof(uacpi_char);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status make_null_string(uacpi_buffer *buf)
+{
+ return do_make_empty_object(buf, UACPI_TRUE);
+}
+
+static uacpi_status make_null_buffer(uacpi_buffer *buf)
+{
+ /*
+ * Allocate at least 1 byte just to be safe,
+ * even for empty buffers. We still set the
+ * size to 0 though.
+ */
+ return do_make_empty_object(buf, UACPI_FALSE);
+}
+
+static uacpi_status handle_to(struct execution_context *ctx)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src, *dst;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 2)->obj;
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_ToIntegerOp:
+ // NT always takes the first 8 bytes, even for revision 1
+ dst->integer = object_to_integer(src, 8);
+ break;
+
+ case UACPI_AML_OP_ToHexStringOp:
+ case UACPI_AML_OP_ToDecimalStringOp: {
+ uacpi_bool is_hex = op_ctx->op->code == UACPI_AML_OP_ToHexStringOp;
+
+ if (src->type == UACPI_OBJECT_INTEGER) {
+ ret = integer_to_string(src->integer, dst->buffer, is_hex);
+ break;
+ } else if (src->type == UACPI_OBJECT_BUFFER) {
+ if (uacpi_unlikely(src->buffer->size == 0))
+ return make_null_string(dst->buffer);
+
+ ret = buffer_to_string(src->buffer, dst->buffer, is_hex);
+ break;
+ }
+ UACPI_FALLTHROUGH;
+ }
+ case UACPI_AML_OP_ToBufferOp: {
+ uacpi_data_view buf;
+ uacpi_u8 *dst_buf;
+
+ ret = get_object_storage(src, &buf, UACPI_TRUE);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely(buf.length == 0))
+ return make_null_buffer(dst->buffer);
+
+ dst_buf = uacpi_kernel_alloc(buf.length);
+ if (uacpi_unlikely(dst_buf == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(dst_buf, buf.bytes, buf.length);
+ dst->buffer->data = dst_buf;
+ dst->buffer->size = buf.length;
+ break;
+ }
+
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ret;
+}
+
+static uacpi_status handle_to_string(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_buffer *src_buf, *dst_buf;
+ uacpi_size req_len, len;
+
+ src_buf = item_array_at(&op_ctx->items, 0)->obj->buffer;
+ req_len = item_array_at(&op_ctx->items, 1)->obj->integer;
+ dst_buf = item_array_at(&op_ctx->items, 3)->obj->buffer;
+
+ len = UACPI_MIN(req_len, src_buf->size);
+ if (uacpi_unlikely(len == 0))
+ return make_null_string(dst_buf);
+
+ len = uacpi_strnlen(src_buf->text, len);
+
+ dst_buf->text = uacpi_kernel_alloc(len + 1);
+ if (uacpi_unlikely(dst_buf->text == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(dst_buf->text, src_buf->data, len);
+ dst_buf->text[len] = '\0';
+ dst_buf->size = len + 1;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_mid(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src, *dst;
+ uacpi_data_view src_buf;
+ uacpi_buffer *dst_buf;
+ uacpi_size idx, len;
+ uacpi_bool is_string;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ if (uacpi_unlikely(src->type != UACPI_OBJECT_STRING &&
+ src->type != UACPI_OBJECT_BUFFER)) {
+ uacpi_error(
+ "invalid argument for Mid: %s, expected String/Buffer\n",
+ uacpi_object_type_to_string(src->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ idx = item_array_at(&op_ctx->items, 1)->obj->integer;
+ len = item_array_at(&op_ctx->items, 2)->obj->integer;
+ dst = item_array_at(&op_ctx->items, 4)->obj;
+ dst_buf = dst->buffer;
+
+ is_string = src->type == UACPI_OBJECT_STRING;
+ get_object_storage(src, &src_buf, UACPI_FALSE);
+
+ if (uacpi_unlikely(src_buf.length == 0 || idx >= src_buf.length ||
+ len == 0)) {
+ if (src->type == UACPI_OBJECT_STRING) {
+ dst->type = UACPI_OBJECT_STRING;
+ return make_null_string(dst_buf);
+ }
+
+ return make_null_buffer(dst_buf);
+ }
+
+ // Guaranteed to be at least 1 here
+ len = UACPI_MIN(len, src_buf.length - idx);
+
+ dst_buf->data = uacpi_kernel_alloc(len + is_string);
+ if (uacpi_unlikely(dst_buf->data == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(dst_buf->data, (uacpi_u8*)src_buf.bytes + idx, len);
+ dst_buf->size = len;
+
+ if (is_string) {
+ dst_buf->text[dst_buf->size++] = '\0';
+ dst->type = UACPI_OBJECT_STRING;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_concatenate(struct execution_context *ctx)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *arg0, *arg1, *dst;
+ uacpi_u8 *dst_buf;
+ uacpi_size buf_size = 0;
+
+ arg0 = item_array_at(&op_ctx->items, 0)->obj;
+ arg1 = item_array_at(&op_ctx->items, 1)->obj;
+ dst = item_array_at(&op_ctx->items, 3)->obj;
+
+ switch (arg0->type) {
+ case UACPI_OBJECT_INTEGER: {
+ uacpi_u64 arg1_as_int;
+ uacpi_size int_size;
+
+ int_size = sizeof_int();
+ buf_size = int_size * 2;
+
+ dst_buf = uacpi_kernel_alloc(buf_size);
+ if (uacpi_unlikely(dst_buf == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ arg1_as_int = object_to_integer(arg1, 8);
+
+ uacpi_memcpy(dst_buf, &arg0->integer, int_size);
+ uacpi_memcpy(dst_buf+ int_size, &arg1_as_int, int_size);
+ break;
+ }
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_buffer *arg0_buf = arg0->buffer;
+ uacpi_data_view arg1_buf = { 0 };
+
+ get_object_storage(arg1, &arg1_buf, UACPI_TRUE);
+ buf_size = arg0_buf->size + arg1_buf.length;
+
+ dst_buf = uacpi_kernel_alloc(buf_size);
+ if (uacpi_unlikely(dst_buf == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(dst_buf, arg0_buf->data, arg0_buf->size);
+ uacpi_memcpy(dst_buf + arg0_buf->size, arg1_buf.bytes, arg1_buf.length);
+ break;
+ }
+ case UACPI_OBJECT_STRING: {
+ uacpi_char int_buf[17];
+ void *arg1_ptr;
+ uacpi_size arg0_size, arg1_size;
+ uacpi_buffer *arg0_buf = arg0->buffer;
+
+ switch (arg1->type) {
+ case UACPI_OBJECT_INTEGER: {
+ int size;
+ size = uacpi_snprintf(int_buf, sizeof(int_buf), "%"UACPI_PRIx64,
+ UACPI_FMT64(arg1->integer));
+ if (size < 0)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ arg1_ptr = int_buf;
+ arg1_size = size + 1;
+ break;
+ }
+ case UACPI_OBJECT_STRING:
+ arg1_ptr = arg1->buffer->data;
+ arg1_size = arg1->buffer->size;
+ break;
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_buffer tmp_buf;
+
+ ret = buffer_to_string(arg1->buffer, &tmp_buf, UACPI_TRUE);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ arg1_ptr = tmp_buf.data;
+ arg1_size = tmp_buf.size;
+ break;
+ }
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ arg0_size = arg0_buf->size ? arg0_buf->size - 1 : arg0_buf->size;
+ buf_size = arg0_size + arg1_size;
+
+ dst_buf = uacpi_kernel_alloc(buf_size);
+ if (uacpi_unlikely(dst_buf == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto cleanup;
+ }
+
+ uacpi_memcpy(dst_buf, arg0_buf->data, arg0_size);
+ uacpi_memcpy(dst_buf + arg0_size, arg1_ptr, arg1_size);
+ dst->type = UACPI_OBJECT_STRING;
+
+ cleanup:
+ if (arg1->type == UACPI_OBJECT_BUFFER)
+ uacpi_free(arg1_ptr, arg1_size);
+ break;
+ }
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_likely_success(ret)) {
+ dst->buffer->data = dst_buf;
+ dst->buffer->size = buf_size;
+ }
+ return ret;
+}
+
+static uacpi_status handle_concatenate_res(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_data_view buffer;
+ uacpi_object *arg0, *arg1, *dst;
+ uacpi_u8 *dst_buf;
+ uacpi_size dst_size, arg0_size, arg1_size;
+
+ arg0 = item_array_at(&op_ctx->items, 0)->obj;
+ arg1 = item_array_at(&op_ctx->items, 1)->obj;
+ dst = item_array_at(&op_ctx->items, 3)->obj;
+
+ uacpi_buffer_to_view(arg0->buffer, &buffer);
+ ret = uacpi_find_aml_resource_end_tag(buffer, &arg0_size);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ uacpi_buffer_to_view(arg1->buffer, &buffer);
+ ret = uacpi_find_aml_resource_end_tag(buffer, &arg1_size);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ dst_size = arg0_size + arg1_size + sizeof(struct acpi_resource_end_tag);
+
+ dst_buf = uacpi_kernel_alloc(dst_size);
+ if (uacpi_unlikely(dst_buf == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ dst->buffer->data = dst_buf;
+ dst->buffer->size = dst_size;
+
+ uacpi_memcpy(dst_buf, arg0->buffer->data, arg0_size);
+ uacpi_memcpy(dst_buf + arg0_size, arg1->buffer->data, arg1_size);
+
+ /*
+ * Small item (0), End Tag (0x0F), length 1
+ * Leave the checksum as 0
+ */
+ dst_buf[dst_size - 2] =
+ (ACPI_RESOURCE_END_TAG << ACPI_SMALL_ITEM_NAME_IDX) |
+ (sizeof(struct acpi_resource_end_tag) - 1);
+ dst_buf[dst_size - 1] = 0;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_sizeof(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src, *dst;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (uacpi_likely(src->type == UACPI_OBJECT_REFERENCE))
+ src = reference_unwind(src)->inner_object;
+
+ switch (src->type) {
+ case UACPI_OBJECT_STRING:
+ case UACPI_OBJECT_BUFFER: {
+ uacpi_data_view buf;
+ get_object_storage(src, &buf, UACPI_FALSE);
+
+ dst->integer = buf.length;
+ break;
+ }
+
+ case UACPI_OBJECT_PACKAGE:
+ dst->integer = src->package->count;
+ break;
+
+ default:
+ uacpi_error(
+ "invalid argument for Sizeof: %s, "
+ "expected String/Buffer/Package\n",
+ uacpi_object_type_to_string(src->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_object_type(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src, *dst;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (uacpi_likely(src->type == UACPI_OBJECT_REFERENCE))
+ src = reference_unwind(src)->inner_object;
+
+ dst->integer = src->type;
+ if (dst->integer == UACPI_OBJECT_BUFFER_INDEX)
+ dst->integer = UACPI_OBJECT_BUFFER_FIELD;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_timer(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *dst;
+
+ dst = item_array_at(&op_ctx->items, 0)->obj;
+ dst->integer = uacpi_kernel_get_nanoseconds_since_boot() / 100;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_stall_or_sleep(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_u64 time;
+
+ time = item_array_at(&op_ctx->items, 0)->obj->integer;
+
+ if (op_ctx->op->code == UACPI_AML_OP_SleepOp) {
+ /*
+ * ACPICA doesn't allow sleeps longer than 2 seconds,
+ * so we shouldn't either.
+ */
+ if (time > 2000)
+ time = 2000;
+
+ uacpi_namespace_write_unlock();
+ uacpi_kernel_sleep(time);
+ uacpi_namespace_write_lock();
+ } else {
+ // Spec says this must evaluate to a ByteData
+ if (time > 0xFF)
+ time = 0xFF;
+ uacpi_kernel_stall(time);
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_bcd(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_u64 src, dst = 0;
+ uacpi_size i;
+ uacpi_object *dst_obj;
+
+ src = item_array_at(&op_ctx->items, 0)->obj->integer;
+ dst_obj = item_array_at(&op_ctx->items, 2)->obj;
+ i = 64;
+
+ /*
+ * NOTE: ACPICA just errors out for invalid BCD, but NT allows it just fine.
+ * FromBCD matches NT behavior 1:1 even for invalid BCD, but ToBCD
+ * produces different results when the input is too large.
+ */
+ if (op_ctx->op->code == UACPI_AML_OP_FromBCDOp) {
+ do {
+ i -= 4;
+ dst *= 10;
+ dst += (src >> i) & 0xF;
+ } while (i);
+ } else {
+ while (src != 0) {
+ dst >>= 4;
+ i -= 4;
+ dst |= (src % 10) << 60;
+ src /= 10;
+ }
+
+ dst >>= (i % 64);
+ }
+
+ dst_obj->integer = dst;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_unload(struct execution_context *ctx)
+{
+ UACPI_UNUSED(ctx);
+
+ /*
+ * Technically this doesn't exist in the wild, from the dumps that I have
+ * the only user of the Unload opcode is the Surface Pro 3, which triggers
+ * an unload of some I2C-related table as a response to some event.
+ *
+ * This op has been long deprecated by the specification exactly because
+ * it hasn't really been used by anyone and the fact that it introduces
+ * an enormous layer of complexity, which no driver is really prepared to
+ * deal with (aka namespace nodes disappearing under its feet).
+ *
+ * Just pretend we have actually unloaded whatever the AML asked for, if it
+ * ever tries to re-load this table that will just skip opcodes that create
+ * already existing objects, which should be good enough and mostly
+ * transparent to the AML.
+ */
+ uacpi_warn("refusing to unload a table from AML\n");
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_logical_not(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *src, *dst;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ dst->type = UACPI_OBJECT_INTEGER;
+ dst->integer = src->integer ? 0 : ones();
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_bool handle_logical_equality(uacpi_object *lhs, uacpi_object *rhs)
+{
+ uacpi_bool res = UACPI_FALSE;
+
+ if (lhs->type == UACPI_OBJECT_STRING || lhs->type == UACPI_OBJECT_BUFFER) {
+ res = lhs->buffer->size == rhs->buffer->size;
+
+ if (res && lhs->buffer->size) {
+ res = uacpi_memcmp(
+ lhs->buffer->data,
+ rhs->buffer->data,
+ lhs->buffer->size
+ ) == 0;
+ }
+ } else if (lhs->type == UACPI_OBJECT_INTEGER) {
+ res = lhs->integer == rhs->integer;
+ }
+
+ return res;
+}
+
+static uacpi_bool handle_logical_less_or_greater(
+ uacpi_aml_op op, uacpi_object *lhs, uacpi_object *rhs
+)
+{
+ if (lhs->type == UACPI_OBJECT_STRING || lhs->type == UACPI_OBJECT_BUFFER) {
+ int res;
+ uacpi_buffer *lhs_buf, *rhs_buf;
+
+ lhs_buf = lhs->buffer;
+ rhs_buf = rhs->buffer;
+
+ res = uacpi_memcmp(lhs_buf->data, rhs_buf->data,
+ UACPI_MIN(lhs_buf->size, rhs_buf->size));
+ if (res == 0) {
+ if (lhs_buf->size < rhs_buf->size)
+ res = -1;
+ else if (lhs_buf->size > rhs_buf->size)
+ res = 1;
+ }
+
+ if (op == UACPI_AML_OP_LLessOp)
+ return res < 0;
+
+ return res > 0;
+ }
+
+ if (op == UACPI_AML_OP_LLessOp)
+ return lhs->integer < rhs->integer;
+
+ return lhs->integer > rhs->integer;
+}
+
+static uacpi_status handle_binary_logic(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_aml_op op = op_ctx->op->code;
+ uacpi_object *lhs, *rhs, *dst;
+ uacpi_bool res;
+
+ lhs = item_array_at(&op_ctx->items, 0)->obj;
+ rhs = item_array_at(&op_ctx->items, 1)->obj;
+ dst = item_array_at(&op_ctx->items, 2)->obj;
+
+ switch (op) {
+ case UACPI_AML_OP_LEqualOp:
+ case UACPI_AML_OP_LLessOp:
+ case UACPI_AML_OP_LGreaterOp:
+ // TODO: typecheck at parse time
+ if (lhs->type != rhs->type) {
+ uacpi_error(
+ "don't know how to do a logical comparison of '%s' and '%s'\n",
+ uacpi_object_type_to_string(lhs->type),
+ uacpi_object_type_to_string(rhs->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ if (op == UACPI_AML_OP_LEqualOp)
+ res = handle_logical_equality(lhs, rhs);
+ else
+ res = handle_logical_less_or_greater(op, lhs, rhs);
+ break;
+ default: {
+ uacpi_u64 lhs_int, rhs_int;
+
+ // NT only looks at the first 4 bytes of a buffer
+ lhs_int = object_to_integer(lhs, 4);
+ rhs_int = object_to_integer(rhs, 4);
+
+ if (op == UACPI_AML_OP_LandOp)
+ res = lhs_int && rhs_int;
+ else
+ res = lhs_int || rhs_int;
+ break;
+ }
+ }
+
+ dst->integer = res ? ones() : 0;
+ return UACPI_STATUS_OK;
+}
+
+enum match_op {
+ MTR = 0,
+ MEQ = 1,
+ MLE = 2,
+ MLT = 3,
+ MGE = 4,
+ MGT = 5,
+};
+
+static uacpi_bool match_one(enum match_op op, uacpi_u64 lhs, uacpi_u64 rhs)
+{
+ switch (op) {
+ case MTR:
+ return UACPI_TRUE;
+ case MEQ:
+ return lhs == rhs;
+ case MLE:
+ return lhs <= rhs;
+ case MLT:
+ return lhs < rhs;
+ case MGE:
+ return lhs >= rhs;
+ case MGT:
+ return lhs > rhs;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_status handle_match(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_package *pkg;
+ uacpi_u64 operand0, operand1, start_idx, i;
+ enum match_op mop0, mop1;
+ uacpi_object *dst;
+
+ pkg = item_array_at(&op_ctx->items, 0)->obj->package;
+ mop0 = item_array_at(&op_ctx->items, 1)->immediate;
+ operand0 = item_array_at(&op_ctx->items, 2)->obj->integer;
+ mop1 = item_array_at(&op_ctx->items, 3)->immediate;
+ operand1 = item_array_at(&op_ctx->items, 4)->obj->integer;
+ start_idx = item_array_at(&op_ctx->items, 5)->obj->integer;
+ dst = item_array_at(&op_ctx->items, 6)->obj;
+
+ for (i = start_idx; i < pkg->count; ++i) {
+ uacpi_object *obj = pkg->objects[i];
+
+ if (obj->type != UACPI_OBJECT_INTEGER)
+ continue;
+
+ if (match_one(mop0, obj->integer, operand0) &&
+ match_one(mop1, obj->integer, operand1))
+ break;
+ }
+
+ if (i < pkg->count)
+ dst->integer = i;
+ else
+ dst->integer = ones();
+
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * PkgLength :=
+ * PkgLeadByte |
+ * <pkgleadbyte bytedata> |
+ * <pkgleadbyte bytedata bytedata> | <pkgleadbyte bytedata bytedata bytedata>
+ * PkgLeadByte :=
+ * <bit 7-6: bytedata count that follows (0-3)>
+ * <bit 5-4: only used if pkglength < 63>
+ * <bit 3-0: least significant package length nybble>
+ */
+static uacpi_status parse_package_length(struct call_frame *frame,
+ struct package_length *out_pkg)
+{
+ uacpi_u32 left, size;
+ uacpi_u8 *data, marker_length;
+
+ out_pkg->begin = frame->code_offset;
+ marker_length = 1;
+
+ left = call_frame_code_bytes_left(frame);
+ if (uacpi_unlikely(left < 1))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ data = call_frame_cursor(frame);
+ marker_length += *data >> 6;
+
+ if (uacpi_unlikely(left < marker_length))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ switch (marker_length) {
+ case 1:
+ size = *data & 0x3F;
+ break;
+ case 2:
+ case 3:
+ case 4: {
+ uacpi_u32 temp_byte = 0;
+
+ size = *data & 0xF;
+ uacpi_memcpy(&temp_byte, data + 1, marker_length - 1);
+
+ // marker_length - 1 is at most 3, so this shift is safe
+ size |= temp_byte << 4;
+ break;
+ }
+ }
+
+ frame->code_offset += marker_length;
+
+ out_pkg->end = out_pkg->begin + size;
+ if (uacpi_unlikely(out_pkg->end < out_pkg->begin)) {
+ uacpi_error(
+ "PkgLength overflow: start=%u, size=%u\n", out_pkg->begin, size
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * ByteData
+ * // bit 0-2: ArgCount (0-7)
+ * // bit 3: SerializeFlag
+ * // 0 NotSerialized
+ * // 1 Serialized
+ * // bit 4-7: SyncLevel (0x00-0x0f)
+ */
+static void init_method_flags(uacpi_control_method *method, uacpi_u8 flags_byte)
+{
+ method->args = flags_byte & 0x7;
+ method->is_serialized = (flags_byte >> 3) & 1;
+ method->sync_level = flags_byte >> 4;
+}
+
+static uacpi_status handle_create_method(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct uacpi_control_method *this_method, *method;
+ struct package_length *pkg;
+ struct uacpi_namespace_node *node;
+ struct uacpi_object *dst;
+ uacpi_u32 method_begin_offset, method_size;
+
+ this_method = ctx->cur_frame->method;
+ pkg = &item_array_at(&op_ctx->items, 0)->pkg;
+ node = item_array_at(&op_ctx->items, 1)->node;
+ method_begin_offset = item_array_at(&op_ctx->items, 3)->immediate;
+
+ if (uacpi_unlikely(pkg->end < pkg->begin ||
+ pkg->end < method_begin_offset ||
+ pkg->end > this_method->size)) {
+ uacpi_error(
+ "invalid method %.4s bounds [%u..%u] (parent size is %u)\n",
+ node->name.text, method_begin_offset, pkg->end, this_method->size
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ dst = item_array_at(&op_ctx->items, 4)->obj;
+
+ method = dst->method;
+ method_size = pkg->end - method_begin_offset;
+
+ if (method_size) {
+ method->code = uacpi_kernel_alloc(method_size);
+ if (uacpi_unlikely(method->code == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(
+ method->code,
+ ctx->cur_frame->method->code + method_begin_offset,
+ method_size
+ );
+ method->size = method_size;
+ method->owns_code = 1;
+ }
+
+ init_method_flags(method, item_array_at(&op_ctx->items, 2)->immediate);
+
+ node->object = uacpi_create_internal_reference(UACPI_REFERENCE_KIND_NAMED,
+ dst);
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_mutex_or_event(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_namespace_node *node;
+ uacpi_object *dst;
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+
+ if (op_ctx->op->code == UACPI_AML_OP_MutexOp) {
+ dst = item_array_at(&op_ctx->items, 2)->obj;
+
+ // bits 0-3: SyncLevel (0x00-0x0f), bits 4-7: Reserved (must be 0)
+ dst->mutex->sync_level = item_array_at(&op_ctx->items, 1)->immediate;
+ dst->mutex->sync_level &= 0xF;
+ } else {
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+ }
+
+ node->object = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_NAMED,
+ dst
+ );
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_event_ctl(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *obj;
+
+ obj = uacpi_unwrap_internal_reference(
+ item_array_at(&op_ctx->items, 0)->obj
+ );
+ if (uacpi_unlikely(obj->type != UACPI_OBJECT_EVENT)) {
+ uacpi_error(
+ "%s: invalid argument '%s', expected an Event object\n",
+ op_ctx->op->name, uacpi_object_type_to_string(obj->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ switch (op_ctx->op->code)
+ {
+ case UACPI_AML_OP_SignalOp:
+ uacpi_kernel_signal_event(obj->event->handle);
+ break;
+ case UACPI_AML_OP_ResetOp:
+ uacpi_kernel_reset_event(obj->event->handle);
+ break;
+ case UACPI_AML_OP_WaitOp: {
+ uacpi_u64 timeout;
+ uacpi_bool ret;
+
+ timeout = item_array_at(&op_ctx->items, 1)->obj->integer;
+ if (timeout > 0xFFFF)
+ timeout = 0xFFFF;
+
+ uacpi_namespace_write_unlock();
+ ret = uacpi_kernel_wait_for_event(obj->event->handle, timeout);
+ uacpi_namespace_write_lock();
+
+ /*
+ * The return value here is inverted, we return 0 for success and Ones
+ * for timeout and everything else.
+ */
+ if (ret)
+ item_array_at(&op_ctx->items, 2)->obj->integer = 0;
+ break;
+ }
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_mutex_ctl(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_object *obj;
+
+ obj = uacpi_unwrap_internal_reference(
+ item_array_at(&op_ctx->items, 0)->obj
+ );
+ if (uacpi_unlikely(obj->type != UACPI_OBJECT_MUTEX)) {
+ uacpi_error(
+ "%s: invalid argument '%s', expected a Mutex object\n",
+ op_ctx->op->name, uacpi_object_type_to_string(obj->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ switch (op_ctx->op->code)
+ {
+ case UACPI_AML_OP_AcquireOp: {
+ uacpi_u64 timeout;
+ uacpi_u64 *return_value;
+ uacpi_status ret;
+
+ return_value = &item_array_at(&op_ctx->items, 2)->obj->integer;
+
+ if (uacpi_unlikely(ctx->sync_level > obj->mutex->sync_level)) {
+ uacpi_warn(
+ "ignoring attempt to acquire mutex @%p with a lower sync level "
+ "(%d < %d)\n", obj->mutex, obj->mutex->sync_level,
+ ctx->sync_level
+ );
+ break;
+ }
+
+ timeout = item_array_at(&op_ctx->items, 1)->immediate;
+ if (timeout > 0xFFFF)
+ timeout = 0xFFFF;
+
+ if (uacpi_this_thread_owns_aml_mutex(obj->mutex)) {
+ ret = uacpi_acquire_aml_mutex(obj->mutex, timeout);
+ if (uacpi_likely_success(ret))
+ *return_value = 0;
+ break;
+ }
+
+ ret = uacpi_acquire_aml_mutex(obj->mutex, timeout);
+ if (uacpi_unlikely_error(ret))
+ break;
+
+ ret = held_mutexes_array_push(&ctx->held_mutexes, obj->mutex);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_release_aml_mutex(obj->mutex);
+ return ret;
+ }
+
+ ctx->sync_level = obj->mutex->sync_level;
+ *return_value = 0;
+ break;
+ }
+
+ case UACPI_AML_OP_ReleaseOp: {
+ uacpi_status ret;
+
+ if (!uacpi_this_thread_owns_aml_mutex(obj->mutex)) {
+ uacpi_warn(
+ "attempted to release not-previously-acquired mutex object "
+ "@%p (%p)\n", obj->mutex, obj->mutex->handle
+ );
+ break;
+ }
+
+ ret = held_mutexes_array_remove_and_release(
+ &ctx->held_mutexes, obj->mutex,
+ FORCE_RELEASE_NO
+ );
+ if (uacpi_likely_success(ret)) {
+ uacpi_mutex **last_mutex;
+
+ last_mutex = held_mutexes_array_last(&ctx->held_mutexes);
+ if (last_mutex == UACPI_NULL) {
+ ctx->sync_level = 0;
+ break;
+ }
+
+ ctx->sync_level = (*last_mutex)->sync_level;
+ }
+ break;
+ }
+
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_notify(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct uacpi_namespace_node *node;
+ uacpi_u64 value;
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+ value = item_array_at(&op_ctx->items, 1)->obj->integer;
+
+ ret = uacpi_notify_all(node, value);
+ if (uacpi_likely_success(ret))
+ return ret;
+
+ if (ret == UACPI_STATUS_NO_HANDLER) {
+ const uacpi_char *path;
+
+ path = uacpi_namespace_node_generate_absolute_path(node);
+ uacpi_warn(
+ "ignoring firmware Notify(%s, 0x%"UACPI_PRIX64") request, "
+ "no listeners\n", path, UACPI_FMT64(value)
+ );
+ uacpi_free_dynamic_string(path);
+
+ return UACPI_STATUS_OK;
+ }
+
+ if (ret == UACPI_STATUS_INVALID_ARGUMENT) {
+ uacpi_error("Notify() called on an invalid object %.4s\n",
+ node->name.text);
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return ret;
+}
+
+static uacpi_status handle_firmware_request(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_firmware_request req = { 0 };
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_BreakPointOp:
+ req.type = UACPI_FIRMWARE_REQUEST_TYPE_BREAKPOINT;
+ req.breakpoint.ctx = ctx;
+ break;
+ case UACPI_AML_OP_FatalOp:
+ req.type = UACPI_FIRMWARE_REQUEST_TYPE_FATAL;
+ req.fatal.type = item_array_at(&op_ctx->items, 0)->immediate;
+ req.fatal.code = item_array_at(&op_ctx->items, 1)->immediate;
+ req.fatal.arg = item_array_at(&op_ctx->items, 2)->obj->integer;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ uacpi_namespace_write_unlock();
+ uacpi_kernel_handle_firmware_request(&req);
+ uacpi_namespace_write_lock();
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_create_named(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct uacpi_namespace_node *node;
+ uacpi_object *src;
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+ src = item_array_at(&op_ctx->items, 1)->obj;
+
+ node->object = uacpi_create_internal_reference(UACPI_REFERENCE_KIND_NAMED,
+ src);
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_object_type buffer_field_get_read_type(
+ struct uacpi_buffer_field *field
+)
+{
+ if (field->bit_length > (g_uacpi_rt_ctx.is_rev1 ? 32u : 64u) ||
+ field->force_buffer)
+ return UACPI_OBJECT_BUFFER;
+
+ return UACPI_OBJECT_INTEGER;
+}
+
+static uacpi_status field_get_read_type(
+ uacpi_object *obj, uacpi_object_type *out_type
+)
+{
+ if (obj->type == UACPI_OBJECT_BUFFER_FIELD) {
+ *out_type = buffer_field_get_read_type(&obj->buffer_field);
+ return UACPI_STATUS_OK;
+ }
+
+ return uacpi_field_unit_get_read_type(obj->field_unit, out_type);
+}
+
+static uacpi_status field_byte_size(
+ uacpi_object *obj, uacpi_size *out_size
+)
+{
+ uacpi_size bit_length;
+
+ if (obj->type == UACPI_OBJECT_BUFFER_FIELD) {
+ bit_length = obj->buffer_field.bit_length;
+ } else {
+ uacpi_status ret;
+
+ ret = uacpi_field_unit_get_bit_length(obj->field_unit, &bit_length);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ *out_size = uacpi_round_up_bits_to_bytes(bit_length);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_field_read(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct uacpi_namespace_node *node;
+ uacpi_object *src_obj, *dst_obj;
+ uacpi_size dst_size;
+ void *dst = UACPI_NULL;
+ uacpi_data_view wtr_response = { 0 };
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+ src_obj = uacpi_namespace_node_get_object(node);
+ dst_obj = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (op_ctx->op->code == UACPI_AML_OP_InternalOpReadFieldAsBuffer) {
+ uacpi_buffer *buf;
+
+ ret = field_byte_size(src_obj, &dst_size);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (dst_size != 0) {
+ buf = dst_obj->buffer;
+
+ dst = uacpi_kernel_alloc_zeroed(dst_size);
+ if (dst == UACPI_NULL)
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ buf->data = dst;
+ buf->size = dst_size;
+ }
+ } else {
+ dst = &dst_obj->integer;
+ dst_size = sizeof(uacpi_u64);
+ }
+
+ if (src_obj->type == UACPI_OBJECT_BUFFER_FIELD) {
+ uacpi_read_buffer_field(&src_obj->buffer_field, dst);
+ return UACPI_STATUS_OK;
+ }
+
+ ret = uacpi_read_field_unit(
+ src_obj->field_unit, dst, dst_size, &wtr_response
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (wtr_response.data != UACPI_NULL) {
+ uacpi_buffer *buf;
+
+ buf = dst_obj->buffer;
+ buf->data = wtr_response.data;
+ buf->size = wtr_response.length;
+ }
+
+ return ret;
+}
+
+static uacpi_status handle_create_buffer_field(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ struct uacpi_namespace_node *node;
+ uacpi_buffer *src_buf;
+ uacpi_object *field_obj;
+ uacpi_buffer_field *field;
+
+ /*
+ * Layout of items here:
+ * [0] -> Type checked source buffer object
+ * [1] -> Byte/bit index integer object
+ * [2] ( if CreateField) -> bit length integer object
+ * [3] (2 if not CreateField) -> the new namespace node
+ * [4] (3 if not CreateField) -> the buffer field object we're creating here
+ */
+ src_buf = item_array_at(&op_ctx->items, 0)->obj->buffer;
+
+ if (op_ctx->op->code == UACPI_AML_OP_CreateFieldOp) {
+ uacpi_object *idx_obj, *len_obj;
+
+ idx_obj = item_array_at(&op_ctx->items, 1)->obj;
+ len_obj = item_array_at(&op_ctx->items, 2)->obj;
+ node = item_array_at(&op_ctx->items, 3)->node;
+ field_obj = item_array_at(&op_ctx->items, 4)->obj;
+ field = &field_obj->buffer_field;
+
+ field->bit_index = idx_obj->integer;
+
+ if (uacpi_unlikely(!len_obj->integer ||
+ len_obj->integer > 0xFFFFFFFF)) {
+ uacpi_error("invalid bit field length (%u)\n", field->bit_length);
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ field->bit_length = len_obj->integer;
+ field->force_buffer = UACPI_TRUE;
+ } else {
+ uacpi_object *idx_obj;
+
+ idx_obj = item_array_at(&op_ctx->items, 1)->obj;
+ node = item_array_at(&op_ctx->items, 2)->node;
+ field_obj = item_array_at(&op_ctx->items, 3)->obj;
+ field = &field_obj->buffer_field;
+
+ field->bit_index = idx_obj->integer;
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_CreateBitFieldOp:
+ field->bit_length = 1;
+ break;
+ case UACPI_AML_OP_CreateByteFieldOp:
+ field->bit_length = 8;
+ break;
+ case UACPI_AML_OP_CreateWordFieldOp:
+ field->bit_length = 16;
+ break;
+ case UACPI_AML_OP_CreateDWordFieldOp:
+ field->bit_length = 32;
+ break;
+ case UACPI_AML_OP_CreateQWordFieldOp:
+ field->bit_length = 64;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (op_ctx->op->code != UACPI_AML_OP_CreateBitFieldOp)
+ field->bit_index *= 8;
+ }
+
+ if (uacpi_unlikely((field->bit_index + field->bit_length) >
+ src_buf->size * 8)) {
+ uacpi_error(
+ "invalid buffer field: bits [%zu..%zu], buffer size is %zu bytes\n",
+ field->bit_index, field->bit_index + field->bit_length,
+ src_buf->size
+ );
+ return UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX;
+ }
+
+ field->backing = src_buf;
+ uacpi_shareable_ref(field->backing);
+ node->object = uacpi_create_internal_reference(UACPI_REFERENCE_KIND_NAMED,
+ field_obj);
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_control_flow(struct execution_context *ctx)
+{
+ struct call_frame *frame = ctx->cur_frame;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ if (uacpi_unlikely(frame->last_while == UACPI_NULL)) {
+ uacpi_error(
+ "attempting to %s outside of a While block\n",
+ op_ctx->op->code == UACPI_AML_OP_BreakOp ? "Break" : "Continue"
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ for (;;) {
+ if (ctx->cur_block != frame->last_while) {
+ frame_reset_post_end_block(ctx, ctx->cur_block->type);
+ continue;
+ }
+
+ if (op_ctx->op->code == UACPI_AML_OP_BreakOp)
+ frame->code_offset = ctx->cur_block->end;
+ else
+ frame->code_offset = ctx->cur_block->begin;
+ frame_reset_post_end_block(ctx, ctx->cur_block->type);
+ break;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status create_named_scope(struct op_context *op_ctx)
+{
+ uacpi_namespace_node *node;
+ uacpi_object *obj;
+
+ node = item_array_at(&op_ctx->items, 1)->node;
+ obj = item_array_last(&op_ctx->items)->obj;
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_ProcessorOp: {
+ uacpi_processor *proc = obj->processor;
+ proc->id = item_array_at(&op_ctx->items, 2)->immediate;
+ proc->block_address = item_array_at(&op_ctx->items, 3)->immediate;
+ proc->block_length = item_array_at(&op_ctx->items, 4)->immediate;
+ break;
+ }
+
+ case UACPI_AML_OP_PowerResOp: {
+ uacpi_power_resource *power_res = &obj->power_resource;
+ power_res->system_level = item_array_at(&op_ctx->items, 2)->immediate;
+ power_res->resource_order = item_array_at(&op_ctx->items, 3)->immediate;
+ break;
+ }
+
+ default:
+ break;
+ }
+
+ node->object = uacpi_create_internal_reference(UACPI_REFERENCE_KIND_NAMED,
+ obj);
+ if (uacpi_unlikely(node->object == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_code_block(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ switch (op_ctx->op->code) {
+ case UACPI_AML_OP_ProcessorOp:
+ case UACPI_AML_OP_PowerResOp:
+ case UACPI_AML_OP_ThermalZoneOp:
+ case UACPI_AML_OP_DeviceOp: {
+ uacpi_status ret;
+
+ ret = create_named_scope(op_ctx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ UACPI_FALLTHROUGH;
+ }
+ case UACPI_AML_OP_ScopeOp:
+ case UACPI_AML_OP_IfOp:
+ case UACPI_AML_OP_ElseOp:
+ case UACPI_AML_OP_WhileOp: {
+ break;
+ }
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return begin_block_execution(ctx);
+}
+
+static uacpi_status handle_return(struct execution_context *ctx)
+{
+ uacpi_status ret;
+ uacpi_object *dst = UACPI_NULL;
+
+ ctx->cur_frame->code_offset = ctx->cur_frame->method->size;
+ ret = method_get_ret_object(ctx, &dst);
+
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ if (dst == UACPI_NULL)
+ return UACPI_STATUS_OK;
+
+ /*
+ * Should be possible to move here if method returns a literal
+ * like Return(Buffer { ... }), otherwise we have to copy just to
+ * be safe.
+ */
+ return uacpi_object_assign(
+ dst,
+ item_array_at(&ctx->cur_op_ctx->items, 0)->obj,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY
+ );
+}
+
+static void refresh_ctx_pointers(struct execution_context *ctx)
+{
+ struct call_frame *frame = ctx->cur_frame;
+
+ if (frame == UACPI_NULL) {
+ ctx->cur_op_ctx = UACPI_NULL;
+ ctx->prev_op_ctx = UACPI_NULL;
+ ctx->cur_block = UACPI_NULL;
+ return;
+ }
+
+ ctx->cur_op_ctx = op_context_array_last(&frame->pending_ops);
+ ctx->prev_op_ctx = op_context_array_one_before_last(&frame->pending_ops);
+ ctx->cur_block = code_block_array_last(&frame->code_blocks);
+}
+
+static uacpi_bool ctx_has_non_preempted_op(struct execution_context *ctx)
+{
+ return ctx->cur_op_ctx && !ctx->cur_op_ctx->preempted;
+}
+
+enum op_trace_action_type {
+ OP_TRACE_ACTION_BEGIN,
+ OP_TRACE_ACTION_RESUME,
+ OP_TRACE_ACTION_END,
+};
+
+static const uacpi_char *const op_trace_action_types[3] = {
+ [OP_TRACE_ACTION_BEGIN] = "BEGIN",
+ [OP_TRACE_ACTION_RESUME] = "RESUME",
+ [OP_TRACE_ACTION_END] = "END",
+};
+
+static inline void trace_op(
+ const struct uacpi_op_spec *op, enum op_trace_action_type action
+)
+{
+ uacpi_debug(
+ "%s OP '%s' (0x%04X)\n",
+ op_trace_action_types[action], op->name, op->code
+ );
+}
+
+static inline void trace_pop(uacpi_u8 pop)
+{
+ uacpi_debug(" pOP: %s (0x%02X)\n", uacpi_parse_op_to_string(pop), pop);
+}
+
+static uacpi_status frame_push_args(struct call_frame *frame,
+ struct op_context *op_ctx)
+{
+ uacpi_size i;
+
+ /*
+ * MethodCall items:
+ * items[0] -> method namespace node
+ * items[1] -> immediate that was used for parsing the arguments
+ * items[2...nargs-1] -> method arguments
+ * items[-1] -> return value object
+ *
+ * Here we only care about the arguments though.
+ */
+ for (i = 2; i < item_array_size(&op_ctx->items) - 1; i++) {
+ uacpi_object *src, *dst;
+
+ src = item_array_at(&op_ctx->items, i)->obj;
+
+ dst = uacpi_create_internal_reference(UACPI_REFERENCE_KIND_ARG, src);
+ if (uacpi_unlikely(dst == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ frame->args[i - 2] = dst;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status frame_setup_base_scope(struct call_frame *frame,
+ uacpi_namespace_node *scope,
+ uacpi_control_method *method)
+{
+ struct code_block *block;
+
+ block = code_block_array_alloc(&frame->code_blocks);
+ if (uacpi_unlikely(block == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ block->type = CODE_BLOCK_SCOPE;
+ block->node = scope;
+ block->begin = 0;
+ block->end = method->size;
+ frame->method = method;
+ frame->cur_scope = scope;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status push_new_frame(struct execution_context *ctx,
+ struct call_frame **out_frame)
+{
+ struct call_frame_array *call_stack = &ctx->call_stack;
+ struct call_frame *prev_frame;
+
+ *out_frame = call_frame_array_calloc(call_stack);
+ if (uacpi_unlikely(*out_frame == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ /*
+ * Allocating a new frame might have reallocated the dynamic buffer so our
+ * execution_context members might now be pointing to freed memory.
+ * Refresh them here.
+ */
+ prev_frame = call_frame_array_one_before_last(call_stack);
+ ctx->cur_frame = prev_frame;
+ refresh_ctx_pointers(ctx);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_bool maybe_end_block(struct execution_context *ctx)
+{
+ struct code_block *block = ctx->cur_block;
+ struct call_frame *cur_frame = ctx->cur_frame;
+
+ if (!block)
+ return UACPI_FALSE;
+ if (cur_frame->code_offset != block->end)
+ return UACPI_FALSE;
+
+ if (block->type == CODE_BLOCK_WHILE)
+ cur_frame->code_offset = block->begin;
+
+ frame_reset_post_end_block(ctx, block->type);
+ return UACPI_TRUE;
+}
+
+static uacpi_status store_to_target(
+ uacpi_object *dst, uacpi_object *src, uacpi_data_view *wtr_response
+)
+{
+ uacpi_status ret;
+
+ switch (dst->type) {
+ case UACPI_OBJECT_DEBUG:
+ ret = debug_store(src);
+ break;
+ case UACPI_OBJECT_REFERENCE:
+ ret = store_to_reference(dst, src, wtr_response);
+ break;
+
+ case UACPI_OBJECT_BUFFER_INDEX:
+ src = uacpi_unwrap_internal_reference(src);
+ ret = object_assign_with_implicit_cast(dst, src, wtr_response);
+ break;
+
+ case UACPI_OBJECT_INTEGER:
+ // NULL target
+ if (dst->integer == 0) {
+ ret = UACPI_STATUS_OK;
+ break;
+ }
+ UACPI_FALLTHROUGH;
+ default:
+ uacpi_error("attempted to store to an invalid target: %s\n",
+ uacpi_object_type_to_string(dst->type));
+ ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return ret;
+}
+
+static uacpi_status handle_copy_object_or_store(struct execution_context *ctx)
+{
+ uacpi_object *src, *dst;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (op_ctx->op->code == UACPI_AML_OP_StoreOp) {
+ uacpi_status ret;
+ uacpi_data_view wtr_response = { 0 };
+
+ ret = store_to_target(dst, src, &wtr_response);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ /*
+ * This was a write-then-read field access since we got a response
+ * buffer back from this store. Now we have to return this buffer
+ * as a prvalue from the StoreOp so that it can be used by AML to
+ * retrieve the response.
+ */
+ if (wtr_response.data != UACPI_NULL) {
+ uacpi_object *wtr_response_obj;
+
+ wtr_response_obj = uacpi_create_object(UACPI_OBJECT_BUFFER);
+ if (uacpi_unlikely(wtr_response_obj == UACPI_NULL)) {
+ uacpi_free(wtr_response.data, wtr_response.length);
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ wtr_response_obj->buffer->data = wtr_response.data;
+ wtr_response_obj->buffer->size = wtr_response.length;
+
+ uacpi_object_unref(src);
+ item_array_at(&op_ctx->items, 0)->obj = wtr_response_obj;
+ }
+
+ return ret;
+ }
+
+ if (dst->type != UACPI_OBJECT_REFERENCE)
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+
+ return copy_object_to_reference(dst, src);
+}
+
+static uacpi_status handle_inc_dec(struct execution_context *ctx)
+{
+ uacpi_object *src, *dst;
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+ uacpi_bool field_allowed = UACPI_FALSE;
+ uacpi_object_type true_src_type;
+ uacpi_status ret;
+
+ src = item_array_at(&op_ctx->items, 0)->obj;
+ dst = item_array_at(&op_ctx->items, 1)->obj;
+
+ if (src->type == UACPI_OBJECT_REFERENCE) {
+ /*
+ * Increment/Decrement are the only two operators that modify the value
+ * in-place, thus we need very specific dereference rules here.
+ *
+ * Reading buffer fields & field units is only allowed if we were passed
+ * a namestring directly as opposed to some nested reference chain
+ * containing a field at the bottom.
+ */
+ if (src->flags == UACPI_REFERENCE_KIND_NAMED)
+ field_allowed = src->inner_object->type != UACPI_OBJECT_REFERENCE;
+
+ src = reference_unwind(src)->inner_object;
+ } // else buffer index
+
+ true_src_type = src->type;
+
+ switch (true_src_type) {
+ case UACPI_OBJECT_INTEGER:
+ dst->integer = src->integer;
+ break;
+ case UACPI_OBJECT_FIELD_UNIT:
+ case UACPI_OBJECT_BUFFER_FIELD:
+ if (uacpi_unlikely(!field_allowed))
+ goto out_bad_type;
+
+ ret = field_get_read_type(src, &true_src_type);
+ if (uacpi_unlikely_error(ret))
+ goto out_bad_type;
+ if (true_src_type != UACPI_OBJECT_INTEGER)
+ goto out_bad_type;
+
+ if (src->type == UACPI_OBJECT_FIELD_UNIT) {
+ ret = uacpi_read_field_unit(
+ src->field_unit, &dst->integer, sizeof_int(),
+ UACPI_NULL
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ } else {
+ uacpi_read_buffer_field(&src->buffer_field, &dst->integer);
+ }
+ break;
+ case UACPI_OBJECT_BUFFER_INDEX:
+ dst->integer = *buffer_index_cursor(&src->buffer_index);
+ break;
+ default:
+ goto out_bad_type;
+ }
+
+ if (op_ctx->op->code == UACPI_AML_OP_IncrementOp)
+ dst->integer++;
+ else
+ dst->integer--;
+
+ return UACPI_STATUS_OK;
+
+out_bad_type:
+ uacpi_error("Increment/Decrement: invalid object type '%s'\n",
+ uacpi_object_type_to_string(true_src_type));
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+}
+
+static uacpi_status enter_method(
+ struct execution_context *ctx, struct call_frame *new_frame,
+ uacpi_control_method *method
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ uacpi_shareable_ref(method);
+
+ if (!method->is_serialized)
+ return ret;
+
+ if (uacpi_unlikely(ctx->sync_level > method->sync_level)) {
+ uacpi_error(
+ "cannot invoke method @%p, sync level %d is too low "
+ "(current is %d)\n",
+ method, method->sync_level, ctx->sync_level
+ );
+ return UACPI_STATUS_AML_SYNC_LEVEL_TOO_HIGH;
+ }
+
+ if (method->mutex == UACPI_NULL) {
+ method->mutex = uacpi_create_mutex();
+ if (uacpi_unlikely(method->mutex == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ method->mutex->sync_level = method->sync_level;
+ }
+
+ if (!uacpi_this_thread_owns_aml_mutex(method->mutex)) {
+ ret = uacpi_acquire_aml_mutex(method->mutex, 0xFFFF);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = held_mutexes_array_push(&ctx->held_mutexes, method->mutex);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_release_aml_mutex(method->mutex);
+ return ret;
+ }
+ }
+
+ new_frame->prev_sync_level = ctx->sync_level;
+ ctx->sync_level = method->sync_level;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status push_op(struct execution_context *ctx)
+{
+ struct call_frame *frame = ctx->cur_frame;
+ struct op_context *op_ctx;
+
+ op_ctx = op_context_array_calloc(&frame->pending_ops);
+ if (op_ctx == UACPI_NULL)
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ op_ctx->op = ctx->cur_op;
+ refresh_ctx_pointers(ctx);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_bool pop_item(struct op_context *op_ctx)
+{
+ struct item *item;
+
+ if (item_array_size(&op_ctx->items) == 0)
+ return UACPI_FALSE;
+
+ item = item_array_last(&op_ctx->items);
+
+ if (item->type == ITEM_OBJECT)
+ uacpi_object_unref(item->obj);
+
+ if (item->type == ITEM_NAMESPACE_NODE)
+ uacpi_namespace_node_unref(item->node);
+
+ item_array_pop(&op_ctx->items);
+ return UACPI_TRUE;
+}
+
+static void pop_op(struct execution_context *ctx)
+{
+ struct call_frame *frame = ctx->cur_frame;
+ struct op_context *cur_op_ctx = ctx->cur_op_ctx;
+
+ while (pop_item(cur_op_ctx));
+
+ item_array_clear(&cur_op_ctx->items);
+ op_context_array_pop(&frame->pending_ops);
+ refresh_ctx_pointers(ctx);
+}
+
+static void call_frame_clear(struct call_frame *frame)
+{
+ uacpi_size i;
+ op_context_array_clear(&frame->pending_ops);
+ code_block_array_clear(&frame->code_blocks);
+
+ while (temp_namespace_node_array_size(&frame->temp_nodes) != 0) {
+ uacpi_namespace_node *node;
+
+ node = *temp_namespace_node_array_last(&frame->temp_nodes);
+ uacpi_namespace_node_uninstall(node);
+ temp_namespace_node_array_pop(&frame->temp_nodes);
+ }
+ temp_namespace_node_array_clear(&frame->temp_nodes);
+
+ for (i = 0; i < 7; ++i)
+ uacpi_object_unref(frame->args[i]);
+ for (i = 0; i < 8; ++i)
+ uacpi_object_unref(frame->locals[i]);
+
+ uacpi_method_unref(frame->method);
+}
+
+static uacpi_u8 parse_op_generates_item[0x100] = {
+ [UACPI_PARSE_OP_SIMPLE_NAME] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_SUPERNAME] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_TERM_ARG] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_OPERAND] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_STRING] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_COMPUTATIONAL_DATA] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_TARGET] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_PKGLEN] = ITEM_PACKAGE_LENGTH,
+ [UACPI_PARSE_OP_TRACKED_PKGLEN] = ITEM_PACKAGE_LENGTH,
+ [UACPI_PARSE_OP_CREATE_NAMESTRING] = ITEM_NAMESPACE_NODE,
+ [UACPI_PARSE_OP_CREATE_NAMESTRING_OR_NULL_IF_LOAD] = ITEM_NAMESPACE_NODE,
+ [UACPI_PARSE_OP_EXISTING_NAMESTRING] = ITEM_NAMESPACE_NODE,
+ [UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL] = ITEM_NAMESPACE_NODE,
+ [UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL_IF_LOAD] = ITEM_NAMESPACE_NODE,
+ [UACPI_PARSE_OP_LOAD_INLINE_IMM_AS_OBJECT] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_LOAD_INLINE_IMM] = ITEM_IMMEDIATE,
+ [UACPI_PARSE_OP_LOAD_ZERO_IMM] = ITEM_IMMEDIATE,
+ [UACPI_PARSE_OP_LOAD_IMM] = ITEM_IMMEDIATE,
+ [UACPI_PARSE_OP_LOAD_IMM_AS_OBJECT] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_LOAD_FALSE_OBJECT] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_LOAD_TRUE_OBJECT] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_OBJECT_ALLOC] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_OBJECT_ALLOC_TYPED] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_EMPTY_OBJECT_ALLOC] = ITEM_EMPTY_OBJECT,
+ [UACPI_PARSE_OP_OBJECT_CONVERT_TO_SHALLOW_COPY] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_OBJECT_CONVERT_TO_DEEP_COPY] = ITEM_OBJECT,
+ [UACPI_PARSE_OP_RECORD_AML_PC] = ITEM_IMMEDIATE,
+};
+
+static const uacpi_u8 *op_decode_cursor(const struct op_context *ctx)
+{
+ const struct uacpi_op_spec *spec = ctx->op;
+
+ if (spec->properties & UACPI_OP_PROPERTY_OUT_OF_LINE)
+ return &spec->indirect_decode_ops[ctx->pc];
+
+ return &spec->decode_ops[ctx->pc];
+}
+
+static uacpi_u8 op_decode_byte(struct op_context *ctx)
+{
+ uacpi_u8 byte;
+
+ byte = *op_decode_cursor(ctx);
+ ctx->pc++;
+
+ return byte;
+}
+
+static uacpi_aml_op op_decode_aml_op(struct op_context *op_ctx)
+{
+ uacpi_aml_op op = 0;
+
+ op |= op_decode_byte(op_ctx);
+ op |= op_decode_byte(op_ctx) << 8;
+
+ return op;
+}
+
+// MSVC doesn't support __VA_OPT__ so we do this weirdness
+#define EXEC_OP_DO_LVL(lvl, reason, ...) \
+ uacpi_##lvl("Op 0x%04X ('%s'): "reason"\n", \
+ op_ctx->op->code, op_ctx->op->name __VA_ARGS__)
+
+#define EXEC_OP_DO_ERR(reason, ...) EXEC_OP_DO_LVL(error, reason, __VA_ARGS__)
+#define EXEC_OP_DO_WARN(reason, ...) EXEC_OP_DO_LVL(warn, reason, __VA_ARGS__)
+
+#define EXEC_OP_ERR_2(reason, arg0, arg1) EXEC_OP_DO_ERR(reason, ,arg0, arg1)
+#define EXEC_OP_ERR_1(reason, arg0) EXEC_OP_DO_ERR(reason, ,arg0)
+#define EXEC_OP_ERR(reason) EXEC_OP_DO_ERR(reason)
+
+#define EXEC_OP_WARN(reason) EXEC_OP_DO_WARN(reason)
+
+#define SPEC_SIMPLE_NAME "SimpleName := NameString | ArgObj | LocalObj"
+#define SPEC_SUPER_NAME \
+ "SuperName := SimpleName | DebugObj | ReferenceTypeOpcode"
+#define SPEC_TERM_ARG \
+ "TermArg := ExpressionOpcode | DataObject | ArgObj | LocalObj"
+#define SPEC_OPERAND "Operand := TermArg => Integer"
+#define SPEC_STRING "String := TermArg => String"
+#define SPEC_TARGET "Target := SuperName | NullName"
+
+#define SPEC_COMPUTATIONAL_DATA \
+ "ComputationalData := ByteConst | WordConst | DWordConst | QWordConst " \
+ "| String | ConstObj | RevisionOp | DefBuffer"
+
+static uacpi_bool op_wants_supername(enum uacpi_parse_op op)
+{
+ switch (op) {
+ case UACPI_PARSE_OP_SIMPLE_NAME:
+ case UACPI_PARSE_OP_SUPERNAME:
+ case UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_TARGET:
+ return UACPI_TRUE;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_bool op_wants_term_arg_or_operand(enum uacpi_parse_op op)
+{
+ switch (op) {
+ case UACPI_PARSE_OP_TERM_ARG:
+ case UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL:
+ case UACPI_PARSE_OP_OPERAND:
+ case UACPI_PARSE_OP_STRING:
+ case UACPI_PARSE_OP_COMPUTATIONAL_DATA:
+ return UACPI_TRUE;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_bool op_allows_unresolved(enum uacpi_parse_op op)
+{
+ switch (op) {
+ case UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL:
+ return UACPI_TRUE;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_bool op_allows_unresolved_if_load(enum uacpi_parse_op op)
+{
+ switch (op) {
+ case UACPI_PARSE_OP_CREATE_NAMESTRING_OR_NULL_IF_LOAD:
+ case UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL_IF_LOAD:
+ return UACPI_TRUE;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_status op_typecheck(const struct op_context *op_ctx,
+ const struct op_context *cur_op_ctx)
+{
+ const uacpi_char *expected_type_str;
+ uacpi_u8 ok_mask = 0;
+ uacpi_u8 props = cur_op_ctx->op->properties;
+
+ switch (*op_decode_cursor(op_ctx)) {
+ // SimpleName := NameString | ArgObj | LocalObj
+ case UACPI_PARSE_OP_SIMPLE_NAME:
+ expected_type_str = SPEC_SIMPLE_NAME;
+ ok_mask |= UACPI_OP_PROPERTY_SIMPLE_NAME;
+ break;
+
+ // Target := SuperName | NullName
+ case UACPI_PARSE_OP_TARGET:
+ expected_type_str = SPEC_TARGET;
+ ok_mask |= UACPI_OP_PROPERTY_TARGET | UACPI_OP_PROPERTY_SUPERNAME;
+ break;
+
+ // SuperName := SimpleName | DebugObj | ReferenceTypeOpcode
+ case UACPI_PARSE_OP_SUPERNAME:
+ case UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED:
+ expected_type_str = SPEC_SUPER_NAME;
+ ok_mask |= UACPI_OP_PROPERTY_SUPERNAME;
+ break;
+
+ // TermArg := ExpressionOpcode | DataObject | ArgObj | LocalObj
+ case UACPI_PARSE_OP_TERM_ARG:
+ case UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_OPERAND:
+ case UACPI_PARSE_OP_STRING:
+ case UACPI_PARSE_OP_COMPUTATIONAL_DATA:
+ expected_type_str = SPEC_TERM_ARG;
+ ok_mask |= UACPI_OP_PROPERTY_TERM_ARG;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (!(props & ok_mask)) {
+ EXEC_OP_ERR_2("invalid argument: '%s', expected a %s",
+ cur_op_ctx->op->name, expected_type_str);
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status typecheck_obj(
+ const struct op_context *op_ctx,
+ const uacpi_object *obj,
+ enum uacpi_object_type expected_type,
+ const uacpi_char *spec_desc
+)
+{
+ if (uacpi_likely(obj->type == expected_type))
+ return UACPI_STATUS_OK;
+
+ EXEC_OP_ERR_2("invalid argument type: %s, expected a %s",
+ uacpi_object_type_to_string(obj->type), spec_desc);
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+}
+
+static uacpi_status typecheck_operand(
+ const struct op_context *op_ctx,
+ const uacpi_object *obj
+)
+{
+ return typecheck_obj(op_ctx, obj, UACPI_OBJECT_INTEGER, SPEC_OPERAND);
+}
+
+static uacpi_status typecheck_string(
+ const struct op_context *op_ctx,
+ const uacpi_object *obj
+)
+{
+ return typecheck_obj(op_ctx, obj, UACPI_OBJECT_STRING, SPEC_STRING);
+}
+
+static uacpi_status typecheck_computational_data(
+ const struct op_context *op_ctx,
+ const uacpi_object *obj
+)
+{
+ switch (obj->type) {
+ case UACPI_OBJECT_STRING:
+ case UACPI_OBJECT_BUFFER:
+ case UACPI_OBJECT_INTEGER:
+ return UACPI_STATUS_OK;
+ default:
+ EXEC_OP_ERR_2(
+ "invalid argument type: %s, expected a %s",
+ uacpi_object_type_to_string(obj->type),
+ SPEC_COMPUTATIONAL_DATA
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+}
+
+static void emit_op_skip_warn(const struct op_context *op_ctx)
+{
+ EXEC_OP_WARN("skipping due to previous errors");
+}
+
+static void trace_named_object_lookup_or_creation_failure(
+ struct call_frame *frame, uacpi_size offset, enum uacpi_parse_op op,
+ uacpi_status ret, enum uacpi_log_level level
+)
+{
+ static const uacpi_char *oom_prefix = "<...>";
+ static const uacpi_char *empty_string = "";
+ static const uacpi_char *unknown_path = "<unknown-path>";
+ static const uacpi_char *invalid_path = "<invalid-path>";
+
+ uacpi_status conv_ret;
+ const uacpi_char *action;
+ const uacpi_char *requested_path_to_print;
+ const uacpi_char *middle_part = UACPI_NULL;
+ const uacpi_char *prefix_path = UACPI_NULL;
+ uacpi_char *requested_path = UACPI_NULL;
+ uacpi_size length;
+ uacpi_bool is_create;
+
+ is_create = op == UACPI_PARSE_OP_CREATE_NAMESTRING ||
+ op == UACPI_PARSE_OP_CREATE_NAMESTRING_OR_NULL_IF_LOAD;
+
+ if (is_create)
+ action = "create";
+ else
+ action = "lookup";
+
+ conv_ret = name_string_to_path(
+ frame, offset, &requested_path, &length
+ );
+ if (uacpi_unlikely_error(conv_ret)) {
+ if (conv_ret == UACPI_STATUS_OUT_OF_MEMORY)
+ requested_path_to_print = unknown_path;
+ else
+ requested_path_to_print = invalid_path;
+ } else {
+ requested_path_to_print = requested_path;
+ }
+
+ if (requested_path && requested_path[0] != '\\') {
+ prefix_path = uacpi_namespace_node_generate_absolute_path(
+ frame->cur_scope
+ );
+ if (uacpi_unlikely(prefix_path == UACPI_NULL))
+ prefix_path = oom_prefix;
+
+ if (prefix_path[1] != '\0')
+ middle_part = ".";
+ } else {
+ prefix_path = empty_string;
+ }
+
+ if (middle_part == UACPI_NULL)
+ middle_part = empty_string;
+
+ if (length == 5 && !is_create) {
+ uacpi_log_lvl(
+ level,
+ "unable to %s named object '%s' within (or above) "
+ "scope '%s': %s\n", action, requested_path_to_print,
+ prefix_path, uacpi_status_to_string(ret)
+ );
+ } else {
+ uacpi_log_lvl(
+ level,
+ "unable to %s named object '%s%s%s': %s\n",
+ action, prefix_path, middle_part,
+ requested_path_to_print, uacpi_status_to_string(ret)
+ );
+ }
+
+ uacpi_free(requested_path, length);
+ if (prefix_path != oom_prefix && prefix_path != empty_string)
+ uacpi_free_dynamic_string(prefix_path);
+}
+
+static uacpi_status uninstalled_op_handler(struct execution_context *ctx)
+{
+ struct op_context *op_ctx = ctx->cur_op_ctx;
+
+ EXEC_OP_ERR("no dedicated handler installed");
+ return UACPI_STATUS_UNIMPLEMENTED;
+}
+
+enum op_handler {
+ OP_HANDLER_UNINSTALLED = 0,
+ OP_HANDLER_LOCAL,
+ OP_HANDLER_ARG,
+ OP_HANDLER_STRING,
+ OP_HANDLER_BINARY_MATH,
+ OP_HANDLER_CONTROL_FLOW,
+ OP_HANDLER_CODE_BLOCK,
+ OP_HANDLER_RETURN,
+ OP_HANDLER_CREATE_METHOD,
+ OP_HANDLER_COPY_OBJECT_OR_STORE,
+ OP_HANDLER_INC_DEC,
+ OP_HANDLER_REF_OR_DEREF_OF,
+ OP_HANDLER_LOGICAL_NOT,
+ OP_HANDLER_BINARY_LOGIC,
+ OP_HANDLER_NAMED_OBJECT,
+ OP_HANDLER_BUFFER,
+ OP_HANDLER_PACKAGE,
+ OP_HANDLER_CREATE_NAMED,
+ OP_HANDLER_CREATE_BUFFER_FIELD,
+ OP_HANDLER_READ_FIELD,
+ OP_HANDLER_ALIAS,
+ OP_HANDLER_CONCATENATE,
+ OP_HANDLER_CONCATENATE_RES,
+ OP_HANDLER_SIZEOF,
+ OP_HANDLER_UNARY_MATH,
+ OP_HANDLER_INDEX,
+ OP_HANDLER_OBJECT_TYPE,
+ OP_HANDLER_CREATE_OP_REGION,
+ OP_HANDLER_CREATE_DATA_REGION,
+ OP_HANDLER_CREATE_FIELD,
+ OP_HANDLER_TO,
+ OP_HANDLER_TO_STRING,
+ OP_HANDLER_TIMER,
+ OP_HANDLER_MID,
+ OP_HANDLER_MATCH,
+ OP_HANDLER_CREATE_MUTEX_OR_EVENT,
+ OP_HANDLER_BCD,
+ OP_HANDLER_UNLOAD,
+ OP_HANDLER_LOAD_TABLE,
+ OP_HANDLER_LOAD,
+ OP_HANDLER_STALL_OR_SLEEP,
+ OP_HANDLER_EVENT_CTL,
+ OP_HANDLER_MUTEX_CTL,
+ OP_HANDLER_NOTIFY,
+ OP_HANDLER_FIRMWARE_REQUEST,
+};
+
+static uacpi_status (*op_handlers[])(struct execution_context *ctx) = {
+ /*
+ * All OPs that don't have a handler dispatch to here if
+ * UACPI_PARSE_OP_INVOKE_HANDLER is reached.
+ */
+ [OP_HANDLER_UNINSTALLED] = uninstalled_op_handler,
+ [OP_HANDLER_LOCAL] = handle_local,
+ [OP_HANDLER_ARG] = handle_arg,
+ [OP_HANDLER_NAMED_OBJECT] = handle_named_object,
+ [OP_HANDLER_STRING] = handle_string,
+ [OP_HANDLER_BINARY_MATH] = handle_binary_math,
+ [OP_HANDLER_CONTROL_FLOW] = handle_control_flow,
+ [OP_HANDLER_CODE_BLOCK] = handle_code_block,
+ [OP_HANDLER_RETURN] = handle_return,
+ [OP_HANDLER_CREATE_METHOD] = handle_create_method,
+ [OP_HANDLER_CREATE_MUTEX_OR_EVENT] = handle_create_mutex_or_event,
+ [OP_HANDLER_COPY_OBJECT_OR_STORE] = handle_copy_object_or_store,
+ [OP_HANDLER_INC_DEC] = handle_inc_dec,
+ [OP_HANDLER_REF_OR_DEREF_OF] = handle_ref_or_deref_of,
+ [OP_HANDLER_LOGICAL_NOT] = handle_logical_not,
+ [OP_HANDLER_BINARY_LOGIC] = handle_binary_logic,
+ [OP_HANDLER_BUFFER] = handle_buffer,
+ [OP_HANDLER_PACKAGE] = handle_package,
+ [OP_HANDLER_CREATE_NAMED] = handle_create_named,
+ [OP_HANDLER_CREATE_BUFFER_FIELD] = handle_create_buffer_field,
+ [OP_HANDLER_READ_FIELD] = handle_field_read,
+ [OP_HANDLER_TO] = handle_to,
+ [OP_HANDLER_ALIAS] = handle_create_alias,
+ [OP_HANDLER_CONCATENATE] = handle_concatenate,
+ [OP_HANDLER_CONCATENATE_RES] = handle_concatenate_res,
+ [OP_HANDLER_SIZEOF] = handle_sizeof,
+ [OP_HANDLER_UNARY_MATH] = handle_unary_math,
+ [OP_HANDLER_INDEX] = handle_index,
+ [OP_HANDLER_OBJECT_TYPE] = handle_object_type,
+ [OP_HANDLER_CREATE_OP_REGION] = handle_create_op_region,
+ [OP_HANDLER_CREATE_DATA_REGION] = handle_create_data_region,
+ [OP_HANDLER_CREATE_FIELD] = handle_create_field,
+ [OP_HANDLER_TIMER] = handle_timer,
+ [OP_HANDLER_TO_STRING] = handle_to_string,
+ [OP_HANDLER_MID] = handle_mid,
+ [OP_HANDLER_MATCH] = handle_match,
+ [OP_HANDLER_BCD] = handle_bcd,
+ [OP_HANDLER_UNLOAD] = handle_unload,
+ [OP_HANDLER_LOAD_TABLE] = handle_load_table,
+ [OP_HANDLER_LOAD] = handle_load,
+ [OP_HANDLER_STALL_OR_SLEEP] = handle_stall_or_sleep,
+ [OP_HANDLER_EVENT_CTL] = handle_event_ctl,
+ [OP_HANDLER_MUTEX_CTL] = handle_mutex_ctl,
+ [OP_HANDLER_NOTIFY] = handle_notify,
+ [OP_HANDLER_FIRMWARE_REQUEST] = handle_firmware_request,
+};
+
+static uacpi_u8 handler_idx_of_op[0x100] = {
+ [UACPI_AML_OP_Local0Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local1Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local2Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local3Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local4Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local5Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local6Op] = OP_HANDLER_LOCAL,
+ [UACPI_AML_OP_Local7Op] = OP_HANDLER_LOCAL,
+
+ [UACPI_AML_OP_Arg0Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg1Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg2Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg3Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg4Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg5Op] = OP_HANDLER_ARG,
+ [UACPI_AML_OP_Arg6Op] = OP_HANDLER_ARG,
+
+ [UACPI_AML_OP_StringPrefix] = OP_HANDLER_STRING,
+
+ [UACPI_AML_OP_AddOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_SubtractOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_MultiplyOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_DivideOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_ShiftLeftOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_ShiftRightOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_AndOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_NandOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_OrOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_NorOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_XorOp] = OP_HANDLER_BINARY_MATH,
+ [UACPI_AML_OP_ModOp] = OP_HANDLER_BINARY_MATH,
+
+ [UACPI_AML_OP_IfOp] = OP_HANDLER_CODE_BLOCK,
+ [UACPI_AML_OP_ElseOp] = OP_HANDLER_CODE_BLOCK,
+ [UACPI_AML_OP_WhileOp] = OP_HANDLER_CODE_BLOCK,
+ [UACPI_AML_OP_ScopeOp] = OP_HANDLER_CODE_BLOCK,
+
+ [UACPI_AML_OP_ContinueOp] = OP_HANDLER_CONTROL_FLOW,
+ [UACPI_AML_OP_BreakOp] = OP_HANDLER_CONTROL_FLOW,
+
+ [UACPI_AML_OP_ReturnOp] = OP_HANDLER_RETURN,
+
+ [UACPI_AML_OP_MethodOp] = OP_HANDLER_CREATE_METHOD,
+
+ [UACPI_AML_OP_StoreOp] = OP_HANDLER_COPY_OBJECT_OR_STORE,
+ [UACPI_AML_OP_CopyObjectOp] = OP_HANDLER_COPY_OBJECT_OR_STORE,
+
+ [UACPI_AML_OP_IncrementOp] = OP_HANDLER_INC_DEC,
+ [UACPI_AML_OP_DecrementOp] = OP_HANDLER_INC_DEC,
+
+ [UACPI_AML_OP_RefOfOp] = OP_HANDLER_REF_OR_DEREF_OF,
+ [UACPI_AML_OP_DerefOfOp] = OP_HANDLER_REF_OR_DEREF_OF,
+
+ [UACPI_AML_OP_LnotOp] = OP_HANDLER_LOGICAL_NOT,
+
+ [UACPI_AML_OP_LEqualOp] = OP_HANDLER_BINARY_LOGIC,
+ [UACPI_AML_OP_LandOp] = OP_HANDLER_BINARY_LOGIC,
+ [UACPI_AML_OP_LorOp] = OP_HANDLER_BINARY_LOGIC,
+ [UACPI_AML_OP_LGreaterOp] = OP_HANDLER_BINARY_LOGIC,
+ [UACPI_AML_OP_LLessOp] = OP_HANDLER_BINARY_LOGIC,
+
+ [UACPI_AML_OP_InternalOpNamedObject] = OP_HANDLER_NAMED_OBJECT,
+
+ [UACPI_AML_OP_BufferOp] = OP_HANDLER_BUFFER,
+
+ [UACPI_AML_OP_PackageOp] = OP_HANDLER_PACKAGE,
+ [UACPI_AML_OP_VarPackageOp] = OP_HANDLER_PACKAGE,
+
+ [UACPI_AML_OP_NameOp] = OP_HANDLER_CREATE_NAMED,
+
+ [UACPI_AML_OP_CreateBitFieldOp] = OP_HANDLER_CREATE_BUFFER_FIELD,
+ [UACPI_AML_OP_CreateByteFieldOp] = OP_HANDLER_CREATE_BUFFER_FIELD,
+ [UACPI_AML_OP_CreateWordFieldOp] = OP_HANDLER_CREATE_BUFFER_FIELD,
+ [UACPI_AML_OP_CreateDWordFieldOp] = OP_HANDLER_CREATE_BUFFER_FIELD,
+ [UACPI_AML_OP_CreateQWordFieldOp] = OP_HANDLER_CREATE_BUFFER_FIELD,
+
+ [UACPI_AML_OP_InternalOpReadFieldAsBuffer] = OP_HANDLER_READ_FIELD,
+ [UACPI_AML_OP_InternalOpReadFieldAsInteger] = OP_HANDLER_READ_FIELD,
+
+ [UACPI_AML_OP_ToIntegerOp] = OP_HANDLER_TO,
+ [UACPI_AML_OP_ToBufferOp] = OP_HANDLER_TO,
+ [UACPI_AML_OP_ToDecimalStringOp] = OP_HANDLER_TO,
+ [UACPI_AML_OP_ToHexStringOp] = OP_HANDLER_TO,
+ [UACPI_AML_OP_ToStringOp] = OP_HANDLER_TO_STRING,
+
+ [UACPI_AML_OP_AliasOp] = OP_HANDLER_ALIAS,
+
+ [UACPI_AML_OP_ConcatOp] = OP_HANDLER_CONCATENATE,
+ [UACPI_AML_OP_ConcatResOp] = OP_HANDLER_CONCATENATE_RES,
+
+ [UACPI_AML_OP_SizeOfOp] = OP_HANDLER_SIZEOF,
+
+ [UACPI_AML_OP_NotOp] = OP_HANDLER_UNARY_MATH,
+ [UACPI_AML_OP_FindSetLeftBitOp] = OP_HANDLER_UNARY_MATH,
+ [UACPI_AML_OP_FindSetRightBitOp] = OP_HANDLER_UNARY_MATH,
+
+ [UACPI_AML_OP_IndexOp] = OP_HANDLER_INDEX,
+
+ [UACPI_AML_OP_ObjectTypeOp] = OP_HANDLER_OBJECT_TYPE,
+
+ [UACPI_AML_OP_MidOp] = OP_HANDLER_MID,
+
+ [UACPI_AML_OP_MatchOp] = OP_HANDLER_MATCH,
+
+ [UACPI_AML_OP_NotifyOp] = OP_HANDLER_NOTIFY,
+
+ [UACPI_AML_OP_BreakPointOp] = OP_HANDLER_FIRMWARE_REQUEST,
+};
+
+#define EXT_OP_IDX(op) (op & 0xFF)
+
+static uacpi_u8 handler_idx_of_ext_op[0x100] = {
+ [EXT_OP_IDX(UACPI_AML_OP_CreateFieldOp)] = OP_HANDLER_CREATE_BUFFER_FIELD,
+ [EXT_OP_IDX(UACPI_AML_OP_CondRefOfOp)] = OP_HANDLER_REF_OR_DEREF_OF,
+ [EXT_OP_IDX(UACPI_AML_OP_OpRegionOp)] = OP_HANDLER_CREATE_OP_REGION,
+ [EXT_OP_IDX(UACPI_AML_OP_DeviceOp)] = OP_HANDLER_CODE_BLOCK,
+ [EXT_OP_IDX(UACPI_AML_OP_ProcessorOp)] = OP_HANDLER_CODE_BLOCK,
+ [EXT_OP_IDX(UACPI_AML_OP_PowerResOp)] = OP_HANDLER_CODE_BLOCK,
+ [EXT_OP_IDX(UACPI_AML_OP_ThermalZoneOp)] = OP_HANDLER_CODE_BLOCK,
+ [EXT_OP_IDX(UACPI_AML_OP_TimerOp)] = OP_HANDLER_TIMER,
+ [EXT_OP_IDX(UACPI_AML_OP_MutexOp)] = OP_HANDLER_CREATE_MUTEX_OR_EVENT,
+ [EXT_OP_IDX(UACPI_AML_OP_EventOp)] = OP_HANDLER_CREATE_MUTEX_OR_EVENT,
+
+ [EXT_OP_IDX(UACPI_AML_OP_FieldOp)] = OP_HANDLER_CREATE_FIELD,
+ [EXT_OP_IDX(UACPI_AML_OP_IndexFieldOp)] = OP_HANDLER_CREATE_FIELD,
+ [EXT_OP_IDX(UACPI_AML_OP_BankFieldOp)] = OP_HANDLER_CREATE_FIELD,
+
+ [EXT_OP_IDX(UACPI_AML_OP_FromBCDOp)] = OP_HANDLER_BCD,
+ [EXT_OP_IDX(UACPI_AML_OP_ToBCDOp)] = OP_HANDLER_BCD,
+
+ [EXT_OP_IDX(UACPI_AML_OP_DataRegionOp)] = OP_HANDLER_CREATE_DATA_REGION,
+
+ [EXT_OP_IDX(UACPI_AML_OP_LoadTableOp)] = OP_HANDLER_LOAD_TABLE,
+ [EXT_OP_IDX(UACPI_AML_OP_LoadOp)] = OP_HANDLER_LOAD,
+ [EXT_OP_IDX(UACPI_AML_OP_UnloadOp)] = OP_HANDLER_UNLOAD,
+
+ [EXT_OP_IDX(UACPI_AML_OP_StallOp)] = OP_HANDLER_STALL_OR_SLEEP,
+ [EXT_OP_IDX(UACPI_AML_OP_SleepOp)] = OP_HANDLER_STALL_OR_SLEEP,
+
+ [EXT_OP_IDX(UACPI_AML_OP_SignalOp)] = OP_HANDLER_EVENT_CTL,
+ [EXT_OP_IDX(UACPI_AML_OP_ResetOp)] = OP_HANDLER_EVENT_CTL,
+ [EXT_OP_IDX(UACPI_AML_OP_WaitOp)] = OP_HANDLER_EVENT_CTL,
+
+ [EXT_OP_IDX(UACPI_AML_OP_AcquireOp)] = OP_HANDLER_MUTEX_CTL,
+ [EXT_OP_IDX(UACPI_AML_OP_ReleaseOp)] = OP_HANDLER_MUTEX_CTL,
+
+ [EXT_OP_IDX(UACPI_AML_OP_FatalOp)] = OP_HANDLER_FIRMWARE_REQUEST,
+};
+
+enum method_call_type {
+ METHOD_CALL_NATIVE,
+ METHOD_CALL_AML,
+ METHOD_CALL_TABLE_LOAD,
+};
+
+static uacpi_status prepare_method_call(
+ struct execution_context *ctx, uacpi_namespace_node *node,
+ uacpi_control_method *method, enum method_call_type type,
+ const uacpi_object_array *args
+)
+{
+ uacpi_status ret;
+ struct call_frame *frame;
+
+ if (uacpi_unlikely(call_frame_array_size(&ctx->call_stack) >=
+ g_uacpi_rt_ctx.max_call_stack_depth))
+ return UACPI_STATUS_AML_CALL_STACK_DEPTH_LIMIT;
+
+ ret = push_new_frame(ctx, &frame);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = enter_method(ctx, frame, method);
+ if (uacpi_unlikely_error(ret))
+ goto method_dispatch_error;
+
+ if (type == METHOD_CALL_NATIVE) {
+ uacpi_u8 arg_count;
+
+ arg_count = args ? args->count : 0;
+ if (uacpi_unlikely(arg_count != method->args)) {
+ uacpi_error(
+ "invalid number of arguments %zu to call %.4s, expected %d\n",
+ args ? args->count : 0, node->name.text, method->args
+ );
+
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto method_dispatch_error;
+ }
+
+ if (args != UACPI_NULL) {
+ uacpi_u8 i;
+
+ for (i = 0; i < method->args; ++i) {
+ frame->args[i] = args->objects[i];
+ uacpi_object_ref(args->objects[i]);
+ }
+ }
+ } else if (type == METHOD_CALL_AML) {
+ ret = frame_push_args(frame, ctx->cur_op_ctx);
+ if (uacpi_unlikely_error(ret))
+ goto method_dispatch_error;
+ }
+
+ ret = frame_setup_base_scope(frame, node, method);
+ if (uacpi_unlikely_error(ret))
+ goto method_dispatch_error;
+
+ ctx->cur_frame = frame;
+ ctx->cur_op_ctx = UACPI_NULL;
+ ctx->prev_op_ctx = UACPI_NULL;
+ ctx->cur_block = code_block_array_last(&ctx->cur_frame->code_blocks);
+
+ if (method->native_call) {
+ uacpi_object *retval;
+
+ ret = method_get_ret_object(ctx, &retval);
+ if (uacpi_unlikely_error(ret))
+ goto method_dispatch_error;
+
+ return method->handler(ctx, retval);
+ }
+
+ return UACPI_STATUS_OK;
+
+method_dispatch_error:
+ call_frame_clear(frame);
+ call_frame_array_pop(&ctx->call_stack);
+ return ret;
+}
+
+static void apply_tracked_pkg(
+ struct call_frame *frame, struct op_context *op_ctx
+)
+{
+ struct item *item;
+
+ if (op_ctx->tracked_pkg_idx == 0)
+ return;
+
+ item = item_array_at(&op_ctx->items, op_ctx->tracked_pkg_idx - 1);
+ frame->code_offset = item->pkg.end;
+}
+
+static uacpi_status exec_op(struct execution_context *ctx)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ struct call_frame *frame = ctx->cur_frame;
+ struct op_context *op_ctx;
+ struct item *item = UACPI_NULL;
+ enum uacpi_parse_op prev_op = 0, op;
+
+ /*
+ * Allocate a new op context if previous is preempted (looking for a
+ * dynamic argument), or doesn't exist at all.
+ */
+ if (!ctx_has_non_preempted_op(ctx)) {
+ ret = push_op(ctx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ } else {
+ trace_op(ctx->cur_op_ctx->op, OP_TRACE_ACTION_RESUME);
+ }
+
+ if (ctx->prev_op_ctx)
+ prev_op = *op_decode_cursor(ctx->prev_op_ctx);
+
+ for (;;) {
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ op_ctx = ctx->cur_op_ctx;
+ frame = ctx->cur_frame;
+
+ if (op_ctx->pc == 0 && ctx->prev_op_ctx) {
+ /*
+ * Type check the current arg type against what is expected by the
+ * preempted op. This check is able to catch most type violations
+ * with the only exception being Operand as we only know whether
+ * that evaluates to an integer after the fact.
+ */
+ ret = op_typecheck(ctx->prev_op_ctx, ctx->cur_op_ctx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ op = op_decode_byte(op_ctx);
+ trace_pop(op);
+
+ if (parse_op_generates_item[op] != ITEM_NONE) {
+ item = item_array_alloc(&op_ctx->items);
+ if (uacpi_unlikely(item == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ item->type = parse_op_generates_item[op];
+ if (item->type == ITEM_OBJECT) {
+ enum uacpi_object_type type = UACPI_OBJECT_UNINITIALIZED;
+
+ if (op == UACPI_PARSE_OP_OBJECT_ALLOC_TYPED)
+ type = op_decode_byte(op_ctx);
+
+ item->obj = uacpi_create_object(type);
+ if (uacpi_unlikely(item->obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ } else {
+ uacpi_memzero(&item->immediate, sizeof(item->immediate));
+ }
+ } else if (item == UACPI_NULL) {
+ item = item_array_last(&op_ctx->items);
+ }
+
+ switch (op) {
+ case UACPI_PARSE_OP_END:
+ case UACPI_PARSE_OP_SKIP_WITH_WARN_IF_NULL: {
+ trace_op(ctx->cur_op_ctx->op, OP_TRACE_ACTION_END);
+
+ if (op == UACPI_PARSE_OP_SKIP_WITH_WARN_IF_NULL) {
+ uacpi_u8 idx;
+
+ idx = op_decode_byte(op_ctx);
+ if (item_array_at(&op_ctx->items, idx)->handle != UACPI_NULL)
+ break;
+
+ emit_op_skip_warn(op_ctx);
+ }
+
+ apply_tracked_pkg(frame, op_ctx);
+
+ pop_op(ctx);
+ if (ctx->cur_op_ctx) {
+ ctx->cur_op_ctx->preempted = UACPI_FALSE;
+ ctx->cur_op_ctx->pc++;
+ }
+
+ return UACPI_STATUS_OK;
+ }
+
+ case UACPI_PARSE_OP_EMIT_SKIP_WARN:
+ emit_op_skip_warn(op_ctx);
+ break;
+
+ case UACPI_PARSE_OP_SIMPLE_NAME:
+ case UACPI_PARSE_OP_SUPERNAME:
+ case UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_TERM_ARG:
+ case UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_OPERAND:
+ case UACPI_PARSE_OP_STRING:
+ case UACPI_PARSE_OP_COMPUTATIONAL_DATA:
+ case UACPI_PARSE_OP_TARGET:
+ /*
+ * Preempt this op parsing for now as we wait for the dynamic arg
+ * to be parsed.
+ */
+ op_ctx->preempted = UACPI_TRUE;
+ op_ctx->pc--;
+ return UACPI_STATUS_OK;
+
+ case UACPI_PARSE_OP_TRACKED_PKGLEN:
+ op_ctx->tracked_pkg_idx = item_array_size(&op_ctx->items);
+ UACPI_FALLTHROUGH;
+ case UACPI_PARSE_OP_PKGLEN:
+ ret = parse_package_length(frame, &item->pkg);
+ break;
+
+ case UACPI_PARSE_OP_LOAD_INLINE_IMM:
+ case UACPI_PARSE_OP_LOAD_INLINE_IMM_AS_OBJECT: {
+ void *dst;
+ uacpi_u8 src_width;
+
+ if (op == UACPI_PARSE_OP_LOAD_INLINE_IMM_AS_OBJECT) {
+ item->obj->type = UACPI_OBJECT_INTEGER;
+ dst = &item->obj->integer;
+ src_width = 8;
+ } else {
+ dst = &item->immediate;
+ src_width = op_decode_byte(op_ctx);
+ }
+
+ uacpi_memcpy_zerout(
+ dst, op_decode_cursor(op_ctx),
+ sizeof(uacpi_u64), src_width
+ );
+ op_ctx->pc += src_width;
+ break;
+ }
+
+ case UACPI_PARSE_OP_LOAD_ZERO_IMM:
+ break;
+
+ case UACPI_PARSE_OP_LOAD_IMM:
+ case UACPI_PARSE_OP_LOAD_IMM_AS_OBJECT: {
+ uacpi_u8 width;
+ void *dst;
+
+ width = op_decode_byte(op_ctx);
+ if (uacpi_unlikely(call_frame_code_bytes_left(frame) < width))
+ return UACPI_STATUS_AML_BAD_ENCODING;
+
+ if (op == UACPI_PARSE_OP_LOAD_IMM_AS_OBJECT) {
+ item->obj->type = UACPI_OBJECT_INTEGER;
+ item->obj->integer = 0;
+ dst = &item->obj->integer;
+ } else {
+ dst = item->immediate_bytes;
+ }
+
+ uacpi_memcpy(dst, call_frame_cursor(frame), width);
+ frame->code_offset += width;
+ break;
+ }
+
+ case UACPI_PARSE_OP_LOAD_FALSE_OBJECT:
+ case UACPI_PARSE_OP_LOAD_TRUE_OBJECT: {
+ uacpi_object *obj = item->obj;
+ obj->type = UACPI_OBJECT_INTEGER;
+ obj->integer = op == UACPI_PARSE_OP_LOAD_FALSE_OBJECT ? 0 : ones();
+ break;
+ }
+
+ case UACPI_PARSE_OP_RECORD_AML_PC:
+ item->immediate = frame->code_offset;
+ break;
+
+ case UACPI_PARSE_OP_TRUNCATE_NUMBER:
+ truncate_number_if_needed(item->obj);
+ break;
+
+ case UACPI_PARSE_OP_TYPECHECK: {
+ enum uacpi_object_type expected_type;
+
+ expected_type = op_decode_byte(op_ctx);
+
+ if (uacpi_unlikely(item->obj->type != expected_type)) {
+ EXEC_OP_ERR_2("bad object type: expected %s, got %s!",
+ uacpi_object_type_to_string(expected_type),
+ uacpi_object_type_to_string(item->obj->type));
+ ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_BAD_OPCODE:
+ case UACPI_PARSE_OP_UNREACHABLE:
+ EXEC_OP_ERR("invalid/unexpected opcode");
+ ret = UACPI_STATUS_AML_INVALID_OPCODE;
+ break;
+
+ case UACPI_PARSE_OP_AML_PC_DECREMENT:
+ frame->code_offset--;
+ break;
+
+ case UACPI_PARSE_OP_IMM_DECREMENT:
+ item_array_at(&op_ctx->items, op_decode_byte(op_ctx))->immediate--;
+ break;
+
+ case UACPI_PARSE_OP_ITEM_POP:
+ pop_item(op_ctx);
+ item = item_array_last(&op_ctx->items);
+ break;
+
+ case UACPI_PARSE_OP_IF_HAS_DATA: {
+ uacpi_size pkg_idx = op_ctx->tracked_pkg_idx - 1;
+ struct package_length *pkg;
+ uacpi_u8 bytes_skip;
+
+ bytes_skip = op_decode_byte(op_ctx);
+ pkg = &item_array_at(&op_ctx->items, pkg_idx)->pkg;
+
+ if (frame->code_offset >= pkg->end)
+ op_ctx->pc += bytes_skip;
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_IF_NOT_NULL:
+ case UACPI_PARSE_OP_IF_NULL:
+ case UACPI_PARSE_OP_IF_LAST_NULL:
+ case UACPI_PARSE_OP_IF_LAST_NOT_NULL: {
+ uacpi_u8 idx, bytes_skip;
+ uacpi_bool is_null, skip_if_null;
+
+ if (op == UACPI_PARSE_OP_IF_LAST_NULL ||
+ op == UACPI_PARSE_OP_IF_LAST_NOT_NULL) {
+ is_null = item->handle == UACPI_NULL;
+ } else {
+ idx = op_decode_byte(op_ctx);
+ is_null = item_array_at(&op_ctx->items, idx)->handle == UACPI_NULL;
+ }
+
+ bytes_skip = op_decode_byte(op_ctx);
+ skip_if_null = op == UACPI_PARSE_OP_IF_NOT_NULL ||
+ op == UACPI_PARSE_OP_IF_LAST_NOT_NULL;
+
+ if (is_null == skip_if_null)
+ op_ctx->pc += bytes_skip;
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_IF_LAST_EQUALS: {
+ uacpi_u8 value, bytes_skip;
+
+ value = op_decode_byte(op_ctx);
+ bytes_skip = op_decode_byte(op_ctx);
+
+ if (item->immediate != value)
+ op_ctx->pc += bytes_skip;
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_IF_LAST_FALSE:
+ case UACPI_PARSE_OP_IF_LAST_TRUE: {
+ uacpi_u8 bytes_skip;
+ uacpi_bool is_false, skip_if_false;
+
+ bytes_skip = op_decode_byte(op_ctx);
+ is_false = item->obj->integer == 0;
+ skip_if_false = op == UACPI_PARSE_OP_IF_LAST_TRUE;
+
+ if (is_false == skip_if_false)
+ op_ctx->pc += bytes_skip;
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_JMP: {
+ op_ctx->pc = op_decode_byte(op_ctx);
+ break;
+ }
+
+ case UACPI_PARSE_OP_CREATE_NAMESTRING:
+ case UACPI_PARSE_OP_CREATE_NAMESTRING_OR_NULL_IF_LOAD:
+ case UACPI_PARSE_OP_EXISTING_NAMESTRING:
+ case UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL:
+ case UACPI_PARSE_OP_EXISTING_NAMESTRING_OR_NULL_IF_LOAD: {
+ uacpi_size offset = frame->code_offset;
+ enum resolve_behavior behavior;
+
+ if (op == UACPI_PARSE_OP_CREATE_NAMESTRING ||
+ op == UACPI_PARSE_OP_CREATE_NAMESTRING_OR_NULL_IF_LOAD)
+ behavior = RESOLVE_CREATE_LAST_NAMESEG_FAIL_IF_EXISTS;
+ else
+ behavior = RESOLVE_FAIL_IF_DOESNT_EXIST;
+
+ ret = resolve_name_string(frame, behavior, &item->node);
+
+ if (ret == UACPI_STATUS_NOT_FOUND) {
+ uacpi_bool is_ok;
+
+ if (prev_op) {
+ is_ok = op_allows_unresolved(prev_op);
+ is_ok &= op_allows_unresolved(op);
+ } else {
+ // This is the only standalone op where we allow unresolved
+ is_ok = op_ctx->op->code == UACPI_AML_OP_ExternalOp;
+ }
+
+ if (is_ok)
+ ret = UACPI_STATUS_OK;
+ }
+
+ if (uacpi_unlikely_error(ret)) {
+ enum uacpi_log_level lvl = UACPI_LOG_ERROR;
+ uacpi_status trace_ret = ret;
+ uacpi_bool abort_whileif = UACPI_FALSE;
+
+ if (frame->method->named_objects_persist &&
+ (ret == UACPI_STATUS_AML_OBJECT_ALREADY_EXISTS ||
+ ret == UACPI_STATUS_NOT_FOUND)) {
+ struct op_context *first_ctx;
+
+ first_ctx = op_context_array_at(&frame->pending_ops, 0);
+ abort_whileif = first_ctx->op->code == UACPI_AML_OP_WhileOp ||
+ first_ctx->op->code == UACPI_AML_OP_IfOp;
+
+ if (op_allows_unresolved_if_load(op) || abort_whileif) {
+ lvl = UACPI_LOG_WARN;
+ ret = UACPI_STATUS_OK;
+ }
+ }
+
+ trace_named_object_lookup_or_creation_failure(
+ frame, offset, op, trace_ret, lvl
+ );
+
+ if (abort_whileif) {
+ while (op_context_array_size(&frame->pending_ops) != 1)
+ pop_op(ctx);
+
+ op_ctx = op_context_array_at(&frame->pending_ops, 0);
+ op_ctx->pc++;
+ op_ctx->preempted = UACPI_FALSE;
+ break;
+ }
+
+ if (ret == UACPI_STATUS_NOT_FOUND)
+ ret = UACPI_STATUS_AML_UNDEFINED_REFERENCE;
+ }
+
+ if (behavior == RESOLVE_CREATE_LAST_NAMESEG_FAIL_IF_EXISTS &&
+ !frame->method->named_objects_persist)
+ item->node->flags |= UACPI_NAMESPACE_NODE_FLAG_TEMPORARY;
+
+ break;
+ }
+
+ case UACPI_PARSE_OP_INVOKE_HANDLER: {
+ uacpi_aml_op code = op_ctx->op->code;
+ uacpi_u8 idx;
+
+ if (code <= 0xFF)
+ idx = handler_idx_of_op[code];
+ else
+ idx = handler_idx_of_ext_op[EXT_OP_IDX(code)];
+
+ ret = op_handlers[idx](ctx);
+ break;
+ }
+
+ case UACPI_PARSE_OP_INSTALL_NAMESPACE_NODE:
+ item = item_array_at(&op_ctx->items, op_decode_byte(op_ctx));
+ ret = do_install_node_item(frame, item);
+ break;
+
+ case UACPI_PARSE_OP_OBJECT_TRANSFER_TO_PREV:
+ case UACPI_PARSE_OP_OBJECT_COPY_TO_PREV: {
+ uacpi_object *src;
+ struct item *dst;
+
+ if (!ctx->prev_op_ctx)
+ break;
+
+ switch (prev_op) {
+ case UACPI_PARSE_OP_TERM_ARG_UNWRAP_INTERNAL:
+ case UACPI_PARSE_OP_COMPUTATIONAL_DATA:
+ case UACPI_PARSE_OP_OPERAND:
+ case UACPI_PARSE_OP_STRING:
+ src = uacpi_unwrap_internal_reference(item->obj);
+
+ if (prev_op == UACPI_PARSE_OP_OPERAND)
+ ret = typecheck_operand(ctx->prev_op_ctx, src);
+ else if (prev_op == UACPI_PARSE_OP_STRING)
+ ret = typecheck_string(ctx->prev_op_ctx, src);
+ else if (prev_op == UACPI_PARSE_OP_COMPUTATIONAL_DATA)
+ ret = typecheck_computational_data(ctx->prev_op_ctx, src);
+
+ break;
+ case UACPI_PARSE_OP_SUPERNAME:
+ case UACPI_PARSE_OP_SUPERNAME_OR_UNRESOLVED:
+ src = item->obj;
+ break;
+
+ case UACPI_PARSE_OP_SIMPLE_NAME:
+ case UACPI_PARSE_OP_TERM_ARG:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED:
+ case UACPI_PARSE_OP_TARGET:
+ src = item->obj;
+ break;
+
+ default:
+ EXEC_OP_ERR_1("don't know how to copy/transfer object to %d",
+ prev_op);
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ break;
+ }
+
+ if (uacpi_likely_success(ret)) {
+ dst = item_array_last(&ctx->prev_op_ctx->items);
+ dst->type = ITEM_OBJECT;
+
+ if (op == UACPI_PARSE_OP_OBJECT_TRANSFER_TO_PREV) {
+ dst->obj = src;
+ uacpi_object_ref(dst->obj);
+ } else {
+ dst->obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(dst->obj == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ break;
+ }
+
+ ret = uacpi_object_assign(dst->obj, src,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+ }
+ }
+ break;
+ }
+
+ case UACPI_PARSE_OP_STORE_TO_TARGET:
+ case UACPI_PARSE_OP_STORE_TO_TARGET_INDIRECT: {
+ uacpi_object *dst, *src;
+
+ dst = item_array_at(&op_ctx->items, op_decode_byte(op_ctx))->obj;
+
+ if (op == UACPI_PARSE_OP_STORE_TO_TARGET_INDIRECT) {
+ src = item_array_at(&op_ctx->items,
+ op_decode_byte(op_ctx))->obj;
+ } else {
+ src = item->obj;
+ }
+
+ ret = store_to_target(dst, src, UACPI_NULL);
+ break;
+ }
+
+ // Nothing to do here, object is allocated automatically
+ case UACPI_PARSE_OP_OBJECT_ALLOC:
+ case UACPI_PARSE_OP_OBJECT_ALLOC_TYPED:
+ case UACPI_PARSE_OP_EMPTY_OBJECT_ALLOC:
+ break;
+
+ case UACPI_PARSE_OP_OBJECT_CONVERT_TO_SHALLOW_COPY:
+ case UACPI_PARSE_OP_OBJECT_CONVERT_TO_DEEP_COPY: {
+ uacpi_object *temp = item->obj;
+ enum uacpi_assign_behavior behavior;
+
+ item_array_pop(&op_ctx->items);
+ item = item_array_last(&op_ctx->items);
+
+ if (op == UACPI_PARSE_OP_OBJECT_CONVERT_TO_SHALLOW_COPY)
+ behavior = UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY;
+ else
+ behavior = UACPI_ASSIGN_BEHAVIOR_DEEP_COPY;
+
+ ret = uacpi_object_assign(temp, item->obj, behavior);
+ if (uacpi_unlikely_error(ret))
+ break;
+
+ uacpi_object_unref(item->obj);
+ item->obj = temp;
+ break;
+ }
+
+ case UACPI_PARSE_OP_DISPATCH_METHOD_CALL: {
+ struct uacpi_namespace_node *node;
+ struct uacpi_control_method *method;
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+ method = uacpi_namespace_node_get_object(node)->method;
+
+ ret = prepare_method_call(
+ ctx, node, method, METHOD_CALL_AML, UACPI_NULL
+ );
+ return ret;
+ }
+
+ case UACPI_PARSE_OP_DISPATCH_TABLE_LOAD: {
+ struct uacpi_namespace_node *node;
+ struct uacpi_control_method *method;
+
+ node = item_array_at(&op_ctx->items, 0)->node;
+ method = item_array_at(&op_ctx->items, 1)->obj->method;
+
+ ret = prepare_method_call(
+ ctx, node, method, METHOD_CALL_TABLE_LOAD, UACPI_NULL
+ );
+ return ret;
+ }
+
+ case UACPI_PARSE_OP_CONVERT_NAMESTRING: {
+ uacpi_aml_op new_op = UACPI_AML_OP_InternalOpNamedObject;
+ uacpi_object *obj;
+
+ if (item->node == UACPI_NULL) {
+ if (!op_allows_unresolved(prev_op))
+ ret = UACPI_STATUS_NOT_FOUND;
+ break;
+ }
+
+ obj = uacpi_namespace_node_get_object(item->node);
+
+ switch (obj->type) {
+ case UACPI_OBJECT_METHOD: {
+ uacpi_bool should_invoke;
+
+ switch (prev_op) {
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT:
+ case UACPI_PARSE_OP_TERM_ARG_OR_NAMED_OBJECT_OR_UNRESOLVED:
+ should_invoke = UACPI_FALSE;
+ break;
+ default:
+ should_invoke = !op_wants_supername(prev_op);
+ }
+
+ if (!should_invoke)
+ break;
+
+ new_op = UACPI_AML_OP_InternalOpMethodCall0Args;
+ new_op += obj->method->args;
+ break;
+ }
+
+ case UACPI_OBJECT_BUFFER_FIELD:
+ case UACPI_OBJECT_FIELD_UNIT: {
+ uacpi_object_type type;
+
+ if (!op_wants_term_arg_or_operand(prev_op))
+ break;
+
+ ret = field_get_read_type(obj, &type);
+ if (uacpi_unlikely_error(ret)) {
+ const uacpi_char *field_path;
+
+ field_path = uacpi_namespace_node_generate_absolute_path(
+ item->node
+ );
+
+ uacpi_error(
+ "unable to perform a read from field %s: "
+ "parent opregion gone\n", field_path
+ );
+ uacpi_free_absolute_path(field_path);
+ }
+
+ switch (type) {
+ case UACPI_OBJECT_BUFFER:
+ new_op = UACPI_AML_OP_InternalOpReadFieldAsBuffer;
+ break;
+ case UACPI_OBJECT_INTEGER:
+ new_op = UACPI_AML_OP_InternalOpReadFieldAsInteger;
+ break;
+ default:
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ continue;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ op_ctx->pc = 0;
+ op_ctx->op = uacpi_get_op_spec(new_op);
+ break;
+ }
+
+ case UACPI_PARSE_OP_SWITCH_TO_NEXT_IF_EQUALS: {
+ uacpi_aml_op op, target_op;
+ uacpi_u32 cur_offset;
+ uacpi_u8 op_length;
+
+ cur_offset = frame->code_offset;
+ apply_tracked_pkg(frame, op_ctx);
+ op_length = peek_next_op(frame, &op);
+
+ target_op = op_decode_aml_op(op_ctx);
+ if (op_length == 0 || op != target_op) {
+ // Revert tracked package
+ frame->code_offset = cur_offset;
+ break;
+ }
+
+ frame->code_offset += op_length;
+ op_ctx->switched_from = op_ctx->op->code;
+ op_ctx->op = uacpi_get_op_spec(target_op);
+ op_ctx->pc = 0;
+ break;
+ }
+
+ case UACPI_PARSE_OP_IF_SWITCHED_FROM: {
+ uacpi_aml_op target_op;
+ uacpi_u8 skip_bytes;
+
+ target_op = op_decode_aml_op(op_ctx);
+ skip_bytes = op_decode_byte(op_ctx);
+
+ if (op_ctx->switched_from != target_op)
+ op_ctx->pc += skip_bytes;
+ break;
+ }
+
+ default:
+ EXEC_OP_ERR_1("unhandled parser op '%d'", op);
+ ret = UACPI_STATUS_UNIMPLEMENTED;
+ break;
+ }
+ }
+}
+
+static void ctx_reload_post_ret(struct execution_context *ctx)
+{
+ uacpi_control_method *method = ctx->cur_frame->method;
+
+ if (method->is_serialized) {
+ held_mutexes_array_remove_and_release(
+ &ctx->held_mutexes, method->mutex, FORCE_RELEASE_YES
+ );
+ ctx->sync_level = ctx->cur_frame->prev_sync_level;
+ }
+
+ call_frame_clear(ctx->cur_frame);
+ call_frame_array_pop(&ctx->call_stack);
+
+ ctx->cur_frame = call_frame_array_last(&ctx->call_stack);
+ refresh_ctx_pointers(ctx);
+}
+
+static void trace_method_abort(struct code_block *block, uacpi_size depth)
+{
+ static const uacpi_char *unknown_path = "<unknown>";
+ uacpi_char oom_absolute_path[9] = "<?>.";
+
+ const uacpi_char *absolute_path;
+
+ if (block != UACPI_NULL && block->type == CODE_BLOCK_SCOPE) {
+ absolute_path = uacpi_namespace_node_generate_absolute_path(block->node);
+ if (uacpi_unlikely(absolute_path == UACPI_NULL))
+ uacpi_memcpy(oom_absolute_path + 4, block->node->name.text, 4);
+ } else {
+ absolute_path = unknown_path;
+ }
+
+ uacpi_error(" #%zu in %s()\n", depth, absolute_path);
+
+ if (absolute_path != oom_absolute_path && absolute_path != unknown_path)
+ uacpi_free_dynamic_string(absolute_path);
+}
+
+static void stack_unwind(struct execution_context *ctx)
+{
+ uacpi_size depth;
+ uacpi_bool should_stop;
+
+ /*
+ * Non-empty call stack here means the execution was aborted at some point,
+ * probably due to a bytecode error.
+ */
+ depth = call_frame_array_size(&ctx->call_stack);
+
+ if (depth != 0) {
+ uacpi_size idx = 0;
+ uacpi_bool table_level_code;
+
+ do {
+ table_level_code = ctx->cur_frame->method->named_objects_persist;
+
+ if (table_level_code && idx != 0)
+ /*
+ * This isn't the first frame that we are aborting.
+ * If this is table-level code, we have just unwound a call
+ * chain that had triggered an abort. Stop here, no need to
+ * abort table load because of it.
+ */
+ break;
+
+ while (op_context_array_size(&ctx->cur_frame->pending_ops) != 0)
+ pop_op(ctx);
+
+ trace_method_abort(
+ code_block_array_at(&ctx->cur_frame->code_blocks, 0), idx
+ );
+
+ should_stop = idx++ == 0 && table_level_code;
+ ctx_reload_post_ret(ctx);
+ } while (--depth && !should_stop);
+ }
+}
+
+static void execution_context_release(struct execution_context *ctx)
+{
+ if (ctx->ret)
+ uacpi_object_unref(ctx->ret);
+
+ while (held_mutexes_array_size(&ctx->held_mutexes) != 0) {
+ held_mutexes_array_remove_and_release(
+ &ctx->held_mutexes,
+ *held_mutexes_array_last(&ctx->held_mutexes),
+ FORCE_RELEASE_YES
+ );
+ }
+
+ call_frame_array_clear(&ctx->call_stack);
+ held_mutexes_array_clear(&ctx->held_mutexes);
+ uacpi_free(ctx, sizeof(*ctx));
+}
+
+uacpi_status uacpi_execute_control_method(
+ uacpi_namespace_node *scope, uacpi_control_method *method,
+ const uacpi_object_array *args, uacpi_object **out_obj
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ struct execution_context *ctx;
+
+ ctx = uacpi_kernel_alloc_zeroed(sizeof(*ctx));
+ if (uacpi_unlikely(ctx == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ if (out_obj != UACPI_NULL) {
+ ctx->ret = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(ctx->ret == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+ }
+
+ ret = prepare_method_call(ctx, scope, method, METHOD_CALL_NATIVE, args);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ for (;;) {
+ if (!ctx_has_non_preempted_op(ctx)) {
+ if (ctx->cur_frame == UACPI_NULL)
+ break;
+
+ if (maybe_end_block(ctx))
+ continue;
+
+ if (!call_frame_has_code(ctx->cur_frame)) {
+ ctx_reload_post_ret(ctx);
+ continue;
+ }
+
+ ret = get_op(ctx);
+ if (uacpi_unlikely_error(ret))
+ goto handle_method_abort;
+
+ trace_op(ctx->cur_op, OP_TRACE_ACTION_BEGIN);
+ }
+
+ ret = exec_op(ctx);
+ if (uacpi_unlikely_error(ret))
+ goto handle_method_abort;
+
+ continue;
+
+ handle_method_abort:
+ uacpi_error("aborting %s due to previous error: %s\n",
+ ctx->cur_frame->method->named_objects_persist ?
+ "table load" : "method invocation",
+ uacpi_status_to_string(ret));
+ stack_unwind(ctx);
+
+ /*
+ * Having a frame here implies that we just aborted a dynamic table
+ * load. Signal to the caller that it failed by setting the return
+ * value to false.
+ */
+ if (ctx->cur_frame) {
+ struct item *it;
+
+ it = item_array_last(&ctx->cur_op_ctx->items);
+ if (it != UACPI_NULL && it->obj != UACPI_NULL)
+ it->obj->integer = 0;
+ }
+ }
+
+out:
+ if (ctx->ret != UACPI_NULL) {
+ uacpi_object *ret_obj = UACPI_NULL;
+
+ if (ctx->ret->type != UACPI_OBJECT_UNINITIALIZED) {
+ ret_obj = ctx->ret;
+ uacpi_object_ref(ret_obj);
+ }
+
+ *out_obj = ret_obj;
+ }
+
+ execution_context_release(ctx);
+ return ret;
+}
+
+uacpi_status uacpi_osi(uacpi_handle handle, uacpi_object *retval)
+{
+ struct execution_context *ctx = handle;
+ uacpi_bool is_supported;
+ uacpi_status ret;
+ uacpi_object *arg;
+
+ arg = uacpi_unwrap_internal_reference(ctx->cur_frame->args[0]);
+ if (arg->type != UACPI_OBJECT_STRING) {
+ uacpi_error("_OSI: invalid argument type %s, expected a String\n",
+ uacpi_object_type_to_string(arg->type));
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ if (retval == UACPI_NULL)
+ return UACPI_STATUS_OK;
+
+ retval->type = UACPI_OBJECT_INTEGER;
+
+ ret = uacpi_handle_osi(arg->buffer->text, &is_supported);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ retval->integer = is_supported ? ones() : 0;
+
+ uacpi_trace("_OSI(%s) => reporting as %ssupported\n",
+ arg->buffer->text, is_supported ? "" : "un");
+ return UACPI_STATUS_OK;
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/io.c b/sys/dev/acpi/uacpi/io.c
new file mode 100644
index 0000000..7d10005
--- /dev/null
+++ b/sys/dev/acpi/uacpi/io.c
@@ -0,0 +1,1116 @@
+#include <uacpi/internal/io.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/namespace.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+uacpi_size uacpi_round_up_bits_to_bytes(uacpi_size bit_length)
+{
+ return UACPI_ALIGN_UP(bit_length, 8, uacpi_size) / 8;
+}
+
+static void cut_misaligned_tail(
+ uacpi_u8 *data, uacpi_size offset, uacpi_u32 bit_length
+)
+{
+ uacpi_u8 remainder = bit_length & 7;
+
+ if (remainder == 0)
+ return;
+
+ data[offset] &= ((1ull << remainder) - 1);
+}
+
+struct bit_span
+{
+ union {
+ uacpi_u8 *data;
+ const uacpi_u8 *const_data;
+ };
+ uacpi_u64 index;
+ uacpi_u64 length;
+};
+
+static uacpi_size bit_span_offset(struct bit_span *span, uacpi_size bits)
+{
+ uacpi_size delta = UACPI_MIN(span->length, bits);
+
+ span->index += delta;
+ span->length -= delta;
+
+ return delta;
+}
+
+static void bit_copy(struct bit_span *dst, struct bit_span *src)
+{
+ uacpi_u8 src_shift, dst_shift, bits = 0;
+ uacpi_u16 dst_mask;
+ uacpi_u8 *dst_ptr, *src_ptr;
+ uacpi_u64 dst_count, src_count;
+
+ dst_ptr = dst->data + (dst->index / 8);
+ src_ptr = src->data + (src->index / 8);
+
+ dst_count = dst->length;
+ dst_shift = dst->index & 7;
+
+ src_count = src->length;
+ src_shift = src->index & 7;
+
+ while (dst_count)
+ {
+ bits = 0;
+
+ if (src_count) {
+ bits = *src_ptr >> src_shift;
+
+ if (src_shift && src_count > (uacpi_u32)(8 - src_shift))
+ bits |= *(src_ptr + 1) << (8 - src_shift);
+
+ if (src_count < 8) {
+ bits &= (1 << src_count) - 1;
+ src_count = 0;
+ } else {
+ src_count -= 8;
+ src_ptr++;
+ }
+ }
+
+ dst_mask = (dst_count < 8 ? (1 << dst_count) - 1 : 0xFF) << dst_shift;
+ *dst_ptr = (*dst_ptr & ~dst_mask) | ((bits << dst_shift) & dst_mask);
+
+ if (dst_shift && dst_count > (uacpi_u32)(8 - dst_shift)) {
+ dst_mask >>= 8;
+ *(dst_ptr + 1) &= ~dst_mask;
+ *(dst_ptr + 1) |= (bits >> (8 - dst_shift)) & dst_mask;
+ }
+
+ dst_count = dst_count > 8 ? dst_count - 8 : 0;
+ ++dst_ptr;
+ }
+}
+
+static void do_misaligned_buffer_read(
+ const uacpi_buffer_field *field, uacpi_u8 *dst
+)
+{
+ struct bit_span src_span = { 0 };
+ struct bit_span dst_span = { 0 };
+
+ src_span.index = field->bit_index;
+ src_span.length = field->bit_length;
+ src_span.const_data = field->backing->data;
+
+ dst_span.data = dst;
+ dst_span.length = uacpi_round_up_bits_to_bytes(field->bit_length) * 8;
+ bit_copy(&dst_span, &src_span);
+}
+
+void uacpi_read_buffer_field(
+ const uacpi_buffer_field *field, void *dst
+)
+{
+ if (!(field->bit_index & 7)) {
+ uacpi_u8 *src = field->backing->data;
+ uacpi_size count;
+
+ count = uacpi_round_up_bits_to_bytes(field->bit_length);
+ uacpi_memcpy(dst, src + (field->bit_index / 8), count);
+ cut_misaligned_tail(dst, count - 1, field->bit_length);
+ return;
+ }
+
+ do_misaligned_buffer_read(field, dst);
+}
+
+static void do_write_misaligned_buffer_field(
+ uacpi_buffer_field *field,
+ const void *src, uacpi_size size
+)
+{
+ struct bit_span src_span = { 0 };
+ struct bit_span dst_span = { 0 };
+
+ src_span.length = size * 8;
+ src_span.const_data = src;
+
+ dst_span.index = field->bit_index;
+ dst_span.length = field->bit_length;
+ dst_span.data = field->backing->data;
+
+ bit_copy(&dst_span, &src_span);
+}
+
+void uacpi_write_buffer_field(
+ uacpi_buffer_field *field,
+ const void *src, uacpi_size size
+)
+{
+ if (!(field->bit_index & 7)) {
+ uacpi_u8 *dst, last_byte, tail_shift;
+ uacpi_size count;
+
+ dst = field->backing->data;
+ dst += field->bit_index / 8;
+ count = uacpi_round_up_bits_to_bytes(field->bit_length);
+
+ last_byte = dst[count - 1];
+ tail_shift = field->bit_length & 7;
+
+ uacpi_memcpy_zerout(dst, src, count, size);
+ if (tail_shift) {
+ uacpi_u8 last_shift = 8 - tail_shift;
+ dst[count - 1] = dst[count - 1] << last_shift;
+ dst[count - 1] >>= last_shift;
+ dst[count - 1] |= (last_byte >> tail_shift) << tail_shift;
+ }
+
+ return;
+ }
+
+ do_write_misaligned_buffer_field(field, src, size);
+}
+
+static uacpi_status access_field_unit(
+ uacpi_field_unit *field, uacpi_u32 offset, uacpi_region_op op,
+ union uacpi_opregion_io_data data
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (field->lock_rule) {
+ ret = uacpi_acquire_aml_mutex(
+ g_uacpi_rt_ctx.global_lock_mutex, 0xFFFF
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ switch (field->kind) {
+ case UACPI_FIELD_UNIT_KIND_BANK:
+ ret = uacpi_write_field_unit(
+ field->bank_selection, &field->bank_value, sizeof(field->bank_value),
+ UACPI_NULL
+ );
+ break;
+ case UACPI_FIELD_UNIT_KIND_NORMAL:
+ break;
+ case UACPI_FIELD_UNIT_KIND_INDEX:
+ ret = uacpi_write_field_unit(
+ field->index, &offset, sizeof(offset),
+ UACPI_NULL
+ );
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ switch (op) {
+ case UACPI_REGION_OP_READ:
+ ret = uacpi_read_field_unit(
+ field->data, data.integer, field->access_width_bytes,
+ UACPI_NULL
+ );
+ break;
+ case UACPI_REGION_OP_WRITE:
+ ret = uacpi_write_field_unit(
+ field->data, data.integer, field->access_width_bytes,
+ UACPI_NULL
+ );
+ break;
+ default:
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ break;
+ }
+
+ goto out;
+
+ default:
+ uacpi_error("invalid field unit kind %d\n", field->kind);
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ ret = uacpi_dispatch_opregion_io(field, offset, op, data);
+
+out:
+ if (field->lock_rule)
+ uacpi_release_aml_mutex(g_uacpi_rt_ctx.global_lock_mutex);
+ return ret;
+}
+
+#define SERIAL_HEADER_SIZE 2
+#define IPMI_DATA_SIZE 64
+
+static uacpi_status wtr_buffer_size(
+ uacpi_field_unit *field, uacpi_address_space space,
+ uacpi_size *out_size
+)
+{
+ switch (space) {
+ case UACPI_ADDRESS_SPACE_IPMI:
+ *out_size = SERIAL_HEADER_SIZE + IPMI_DATA_SIZE;
+ break;
+ case UACPI_ADDRESS_SPACE_PRM:
+ *out_size = 26;
+ break;
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ *out_size = 256;
+ break;
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ case UACPI_ADDRESS_SPACE_SMBUS: {
+ uacpi_size size_for_protocol = SERIAL_HEADER_SIZE;
+
+ switch (field->attributes) {
+ case UACPI_ACCESS_ATTRIBUTE_QUICK:
+ break; // + 0
+ case UACPI_ACCESS_ATTRIBUTE_SEND_RECEIVE:
+ case UACPI_ACCESS_ATTRIBUTE_BYTE:
+ size_for_protocol += 1;
+ break;
+
+ case UACPI_ACCESS_ATTRIBUTE_WORD:
+ case UACPI_ACCESS_ATTRIBUTE_PROCESS_CALL:
+ size_for_protocol += 2;
+ break;
+
+ case UACPI_ACCESS_ATTRIBUTE_BYTES:
+ size_for_protocol += field->access_length;
+ break;
+
+ case UACPI_ACCESS_ATTRIBUTE_BLOCK:
+ case UACPI_ACCESS_ATTRIBUTE_BLOCK_PROCESS_CALL:
+ case UACPI_ACCESS_ATTRIBUTE_RAW_BYTES:
+ case UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES:
+ size_for_protocol += 255;
+ break;
+
+ default:
+ uacpi_error(
+ "unsupported field@%p access attribute %d\n",
+ field, field->attributes
+ );
+ return UACPI_STATUS_UNIMPLEMENTED;
+ }
+
+ *out_size = size_for_protocol;
+ break;
+ }
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_special_field(
+ uacpi_field_unit *field, uacpi_data_view buf,
+ uacpi_region_op op, uacpi_data_view *wtr_response,
+ uacpi_bool *did_handle
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ uacpi_object *obj;
+ uacpi_operation_region *region;
+ uacpi_u64 in_out;
+ uacpi_data_view wtr_buffer;
+ union uacpi_opregion_io_data data;
+
+ *did_handle = UACPI_FALSE;
+
+ if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
+ return ret;
+
+ obj = uacpi_namespace_node_get_object_typed(
+ field->region, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ uacpi_trace_region_error(
+ field->region, "attempted access to deleted", ret
+ );
+ goto out_handled;
+ }
+ region = obj->op_region;
+
+ switch (region->space) {
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ if (op == UACPI_REGION_OP_WRITE) {
+ uacpi_memcpy_zerout(
+ &in_out, buf.const_data, sizeof(in_out), buf.length
+ );
+ }
+
+ data.integer = &in_out;
+ ret = access_field_unit(field, 0, op, data);
+ if (uacpi_unlikely_error(ret))
+ goto out_handled;
+
+ if (op == UACPI_REGION_OP_READ)
+ uacpi_memcpy_zerout(buf.data, &in_out, buf.length, sizeof(in_out));
+ goto out_handled;
+ case UACPI_ADDRESS_SPACE_IPMI:
+ case UACPI_ADDRESS_SPACE_PRM:
+ if (uacpi_unlikely(op == UACPI_REGION_OP_READ)) {
+ ret = UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ uacpi_trace_region_error(
+ field->region, "attempted to read from a write-only", ret
+ );
+ goto out_handled;
+ }
+ UACPI_FALLTHROUGH;
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ goto do_wtr;
+ default:
+ return ret;
+ }
+
+do_wtr:
+ ret = wtr_buffer_size(field, region->space, &wtr_buffer.length);
+ if (uacpi_unlikely_error(ret))
+ goto out_handled;
+
+ wtr_buffer.data = uacpi_kernel_alloc(wtr_buffer.length);
+ if (uacpi_unlikely(wtr_buffer.data == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out_handled;
+ }
+
+ uacpi_memcpy_zerout(
+ wtr_buffer.data, buf.const_data, wtr_buffer.length, buf.length
+ );
+ data.buffer = wtr_buffer;
+ ret = access_field_unit(
+ field, field->byte_offset,
+ op, data
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free(wtr_buffer.data, wtr_buffer.length);
+ goto out_handled;
+ }
+
+ if (wtr_response != UACPI_NULL)
+ *wtr_response = wtr_buffer;
+
+out_handled:
+ *did_handle = UACPI_TRUE;
+ return ret;
+}
+
+static uacpi_status do_read_misaligned_field_unit(
+ uacpi_field_unit *field, uacpi_u8 *dst, uacpi_size size
+)
+{
+ uacpi_status ret;
+ uacpi_size reads_to_do;
+ uacpi_u64 out;
+ uacpi_u32 byte_offset = field->byte_offset;
+ uacpi_u32 bits_left = field->bit_length;
+ uacpi_u8 width_access_bits = field->access_width_bytes * 8;
+
+ struct bit_span src_span = { 0 };
+ struct bit_span dst_span = { 0 };
+
+ src_span.data = (uacpi_u8*)&out;
+ src_span.index = field->bit_offset_within_first_byte;
+
+ dst_span.data = dst;
+ dst_span.index = 0;
+ dst_span.length = size * 8;
+
+ reads_to_do = UACPI_ALIGN_UP(
+ field->bit_offset_within_first_byte + field->bit_length,
+ width_access_bits,
+ uacpi_u32
+ );
+ reads_to_do /= width_access_bits;
+
+ while (reads_to_do-- > 0) {
+ union uacpi_opregion_io_data data;
+
+ src_span.length = UACPI_MIN(
+ bits_left, width_access_bits - src_span.index
+ );
+
+ data.integer = &out;
+ ret = access_field_unit(
+ field, byte_offset, UACPI_REGION_OP_READ,
+ data
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ bit_copy(&dst_span, &src_span);
+ bits_left -= src_span.length;
+ src_span.index = 0;
+
+ bit_span_offset(&dst_span, src_span.length);
+ byte_offset += field->access_width_bytes;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_read_field_unit(
+ uacpi_field_unit *field, void *dst, uacpi_size size,
+ uacpi_data_view *wtr_response
+)
+{
+ uacpi_status ret;
+ uacpi_u32 field_byte_length;
+ uacpi_bool did_handle;
+ uacpi_data_view data_view = { 0 };
+
+ data_view.data = dst;
+ data_view.length = size;
+
+ ret = handle_special_field(
+ field, data_view, UACPI_REGION_OP_READ,
+ wtr_response, &did_handle
+ );
+ if (did_handle)
+ return ret;
+
+ field_byte_length = uacpi_round_up_bits_to_bytes(field->bit_length);
+
+ /*
+ * Very simple fast case:
+ * - Bit offset within first byte is 0
+ * AND
+ * - Field size is <= access width
+ */
+ if (field->bit_offset_within_first_byte == 0 &&
+ field_byte_length <= field->access_width_bytes)
+ {
+ uacpi_u64 out;
+ union uacpi_opregion_io_data data;
+
+ data.integer = &out;
+ ret = access_field_unit(
+ field, field->byte_offset, UACPI_REGION_OP_READ,
+ data
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ uacpi_memcpy_zerout(dst, &out, size, field_byte_length);
+ if (size >= field_byte_length)
+ cut_misaligned_tail(dst, field_byte_length - 1, field->bit_length);
+
+ return UACPI_STATUS_OK;
+ }
+
+ // Slow case
+ return do_read_misaligned_field_unit(field, dst, size);
+}
+
+static uacpi_status write_generic_field_unit(
+ uacpi_field_unit *field, const void *src, uacpi_size size
+)
+{
+ uacpi_status ret;
+ uacpi_u32 bits_left, byte_offset = field->byte_offset;
+ uacpi_u8 width_access_bits = field->access_width_bytes * 8;
+ uacpi_u64 in;
+ struct bit_span src_span = { 0 };
+ struct bit_span dst_span = { 0 };
+
+ src_span.const_data = src;
+ src_span.index = 0;
+ src_span.length = size * 8;
+
+ dst_span.data = (uacpi_u8 *)&in;
+ dst_span.index = field->bit_offset_within_first_byte;
+
+ bits_left = field->bit_length;
+
+ while (bits_left) {
+ union uacpi_opregion_io_data data;
+
+ in = 0;
+ dst_span.length = UACPI_MIN(
+ width_access_bits - dst_span.index, bits_left
+ );
+
+ if (dst_span.index != 0 || dst_span.length < width_access_bits) {
+ switch (field->update_rule) {
+ case UACPI_UPDATE_RULE_PRESERVE:
+ data.integer = &in;
+ ret = access_field_unit(
+ field, byte_offset, UACPI_REGION_OP_READ,
+ data
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ break;
+ case UACPI_UPDATE_RULE_WRITE_AS_ONES:
+ in = ~in;
+ break;
+ case UACPI_UPDATE_RULE_WRITE_AS_ZEROES:
+ break;
+ default:
+ uacpi_error("invalid field@%p update rule %d\n",
+ field, field->update_rule);
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+ }
+
+ bit_copy(&dst_span, &src_span);
+ bit_span_offset(&src_span, dst_span.length);
+
+ data.integer = &in;
+
+ ret = access_field_unit(
+ field, byte_offset, UACPI_REGION_OP_WRITE,
+ data
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ bits_left -= dst_span.length;
+ dst_span.index = 0;
+ byte_offset += field->access_width_bytes;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_write_field_unit(
+ uacpi_field_unit *field, const void *src, uacpi_size size,
+ uacpi_data_view *wtr_response
+)
+{
+ uacpi_status ret;
+ uacpi_bool did_handle;
+ uacpi_data_view data_view = { 0 };
+
+ data_view.const_data = src;
+ data_view.length = size;
+
+ ret = handle_special_field(
+ field, data_view, UACPI_REGION_OP_WRITE,
+ wtr_response, &did_handle
+ );
+ if (did_handle)
+ return ret;
+
+ return write_generic_field_unit(field, src, size);
+}
+
+uacpi_status uacpi_field_unit_get_read_type(
+ struct uacpi_field_unit *field, uacpi_object_type *out_type
+)
+{
+ uacpi_object *obj;
+
+ if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
+ goto out_basic_field;
+
+ obj = uacpi_namespace_node_get_object_typed(
+ field->region, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (uacpi_is_buffer_access_address_space(obj->op_region->space)) {
+ *out_type = UACPI_OBJECT_BUFFER;
+ return UACPI_STATUS_OK;
+ }
+
+out_basic_field:
+ if (field->bit_length > (g_uacpi_rt_ctx.is_rev1 ? 32u : 64u))
+ *out_type = UACPI_OBJECT_BUFFER;
+ else
+ *out_type = UACPI_OBJECT_INTEGER;
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_field_unit_get_bit_length(
+ struct uacpi_field_unit *field, uacpi_size *out_length
+)
+{
+ uacpi_object *obj;
+
+ if (field->kind == UACPI_FIELD_UNIT_KIND_INDEX)
+ goto out_basic_field;
+
+ obj = uacpi_namespace_node_get_object_typed(
+ field->region, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (uacpi_is_buffer_access_address_space(obj->op_region->space)) {
+ /*
+ * Bit length is protocol specific, the data will be returned
+ * via the write-then-read response buffer.
+ */
+ *out_length = 0;
+ return UACPI_STATUS_OK;
+ }
+
+out_basic_field:
+ *out_length = field->bit_length;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_u8 gas_get_access_bit_width(const struct acpi_gas *gas)
+{
+ /*
+ * Same algorithm as ACPICA.
+ *
+ * The reason we do this is apparently GAS bit offset being non-zero means
+ * that it's an APEI register, as opposed to FADT, which needs special
+ * handling. In the case of a FADT register we want to ignore the specified
+ * access size.
+ */
+ uacpi_u8 access_bit_width;
+
+ if (gas->register_bit_offset == 0 &&
+ UACPI_IS_POWER_OF_TWO(gas->register_bit_width, uacpi_u8) &&
+ UACPI_IS_ALIGNED(gas->register_bit_width, 8, uacpi_u8)) {
+ access_bit_width = gas->register_bit_width;
+ } else if (gas->access_size) {
+ access_bit_width = gas->access_size * 8;
+ } else {
+ uacpi_u8 msb;
+
+ msb = uacpi_bit_scan_backward(
+ (gas->register_bit_offset + gas->register_bit_width) - 1
+ );
+ access_bit_width = 1 << msb;
+
+ if (access_bit_width <= 8) {
+ access_bit_width = 8;
+ } else {
+ /*
+ * Keep backing off to previous power of two until we find one
+ * that is aligned to the address specified in GAS.
+ */
+ while (!UACPI_IS_ALIGNED(
+ gas->address, access_bit_width / 8, uacpi_u64
+ ))
+ access_bit_width /= 2;
+ }
+ }
+
+ return UACPI_MIN(
+ access_bit_width,
+ gas->address_space_id == UACPI_ADDRESS_SPACE_SYSTEM_IO ? 32 : 64
+ );
+}
+
+static uacpi_status gas_validate(
+ const struct acpi_gas *gas, uacpi_u8 *access_bit_width,
+ uacpi_u8 *bit_width
+)
+{
+ uacpi_size total_width, aligned_width;
+
+ if (uacpi_unlikely(gas == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (!gas->address)
+ return UACPI_STATUS_NOT_FOUND;
+
+ if (gas->address_space_id != UACPI_ADDRESS_SPACE_SYSTEM_IO &&
+ gas->address_space_id != UACPI_ADDRESS_SPACE_SYSTEM_MEMORY) {
+ uacpi_warn("unsupported GAS address space '%s' (%d)\n",
+ uacpi_address_space_to_string(gas->address_space_id),
+ gas->address_space_id);
+ return UACPI_STATUS_UNIMPLEMENTED;
+ }
+
+ if (gas->access_size > 4) {
+ uacpi_warn("unsupported GAS access size %d\n",
+ gas->access_size);
+ return UACPI_STATUS_UNIMPLEMENTED;
+ }
+
+ *access_bit_width = gas_get_access_bit_width(gas);
+
+ total_width = gas->register_bit_offset + gas->register_bit_width;
+ aligned_width = UACPI_ALIGN_UP(total_width, *access_bit_width, uacpi_size);
+
+ if (uacpi_unlikely(aligned_width > 64)) {
+ uacpi_warn(
+ "GAS register total width is too large: %zu\n", total_width
+ );
+ return UACPI_STATUS_UNIMPLEMENTED;
+ }
+
+ *bit_width = total_width;
+ return UACPI_STATUS_OK;
+}
+
+/*
+ * Apparently both reading and writing GAS works differently from operation
+ * region in that bit offsets are not respected when writing the data.
+ *
+ * Let's follow ACPICA's approach here so that we don't accidentally
+ * break any quirky hardware.
+ */
+uacpi_status uacpi_gas_read_mapped(
+ const uacpi_mapped_gas *gas, uacpi_u64 *out_value
+)
+{
+ uacpi_status ret;
+ uacpi_u8 access_byte_width;
+ uacpi_u8 bit_offset, bits_left, index = 0;
+ uacpi_u64 data, mask = 0xFFFFFFFFFFFFFFFF;
+ uacpi_size offset = 0;
+
+ bit_offset = gas->bit_offset;
+ bits_left = gas->total_bit_width;
+
+ access_byte_width = gas->access_bit_width / 8;
+
+ if (access_byte_width < 8)
+ mask = ~(mask << gas->access_bit_width);
+
+ *out_value = 0;
+
+ while (bits_left) {
+ if (bit_offset >= gas->access_bit_width) {
+ data = 0;
+ bit_offset -= gas->access_bit_width;
+ } else {
+ ret = gas->read(gas->mapping, offset, access_byte_width, &data);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ *out_value |= (data & mask) << (index * gas->access_bit_width);
+ bits_left -= UACPI_MIN(bits_left, gas->access_bit_width);
+ ++index;
+ offset += access_byte_width;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_gas_write_mapped(
+ const uacpi_mapped_gas *gas, uacpi_u64 in_value
+)
+{
+ uacpi_status ret;
+ uacpi_u8 access_byte_width;
+ uacpi_u8 bit_offset, bits_left, index = 0;
+ uacpi_u64 data, mask = 0xFFFFFFFFFFFFFFFF;
+ uacpi_size offset = 0;
+
+ bit_offset = gas->bit_offset;
+ bits_left = gas->total_bit_width;
+ access_byte_width = gas->access_bit_width / 8;
+
+ if (access_byte_width < 8)
+ mask = ~(mask << gas->access_bit_width);
+
+ while (bits_left) {
+ data = (in_value >> (index * gas->access_bit_width)) & mask;
+
+ if (bit_offset >= gas->access_bit_width) {
+ bit_offset -= gas->access_bit_width;
+ } else {
+ ret = gas->write(gas->mapping, offset, access_byte_width, data);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ bits_left -= UACPI_MIN(bits_left, gas->access_bit_width);
+ ++index;
+ offset += access_byte_width;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static void unmap_gas_io(uacpi_handle io_handle, uacpi_size size)
+{
+ UACPI_UNUSED(size);
+ uacpi_kernel_io_unmap(io_handle);
+}
+
+uacpi_status uacpi_map_gas_noalloc(
+ const struct acpi_gas *gas, uacpi_mapped_gas *out_mapped
+)
+{
+ uacpi_status ret;
+ uacpi_u8 access_bit_width, total_width;
+
+ ret = gas_validate(gas, &access_bit_width, &total_width);
+ if (ret != UACPI_STATUS_OK)
+ return ret;
+
+ if (gas->address_space_id == UACPI_ADDRESS_SPACE_SYSTEM_MEMORY) {
+ out_mapped->mapping = uacpi_kernel_map(gas->address, total_width / 8);
+ if (uacpi_unlikely(out_mapped->mapping == UACPI_NULL))
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ out_mapped->read = uacpi_system_memory_read;
+ out_mapped->write = uacpi_system_memory_write;
+ out_mapped->unmap = uacpi_kernel_unmap;
+ } else { // IO, validated by gas_validate above
+ ret = uacpi_kernel_io_map(gas->address, total_width / 8, &out_mapped->mapping);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ out_mapped->read = uacpi_system_io_read;
+ out_mapped->write = uacpi_system_io_write;
+ out_mapped->unmap = unmap_gas_io;
+ }
+
+ out_mapped->access_bit_width = access_bit_width;
+ out_mapped->total_bit_width = total_width;
+ out_mapped->bit_offset = gas->register_bit_offset;
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_map_gas(
+ const struct acpi_gas *gas, uacpi_mapped_gas **out_mapped
+)
+{
+ uacpi_status ret;
+ uacpi_mapped_gas *mapping;
+
+ mapping = uacpi_kernel_alloc(sizeof(*mapping));
+ if (uacpi_unlikely(mapping == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ ret = uacpi_map_gas_noalloc(gas, mapping);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free(mapping, sizeof(*mapping));
+ return ret;
+ }
+
+ *out_mapped = mapping;
+ return ret;
+}
+
+void uacpi_unmap_gas_nofree(uacpi_mapped_gas *gas)
+{
+ gas->unmap(gas->mapping, gas->access_bit_width / 8);
+}
+
+void uacpi_unmap_gas(uacpi_mapped_gas *gas)
+{
+ uacpi_unmap_gas_nofree(gas);
+ uacpi_free(gas, sizeof(*gas));
+}
+
+uacpi_status uacpi_gas_read(const struct acpi_gas *gas, uacpi_u64 *out_value)
+{
+ uacpi_status ret;
+ uacpi_mapped_gas mapping;
+
+ ret = uacpi_map_gas_noalloc(gas, &mapping);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_gas_read_mapped(&mapping, out_value);
+ uacpi_unmap_gas_nofree(&mapping);
+
+ return ret;
+}
+
+uacpi_status uacpi_gas_write(const struct acpi_gas *gas, uacpi_u64 in_value)
+{
+ uacpi_status ret;
+ uacpi_mapped_gas mapping;
+
+ ret = uacpi_map_gas_noalloc(gas, &mapping);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_gas_write_mapped(&mapping, in_value);
+ uacpi_unmap_gas_nofree(&mapping);
+
+ return ret;
+}
+
+uacpi_status uacpi_system_memory_read(
+ void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+)
+{
+ ptr = UACPI_PTR_ADD(ptr, offset);
+
+ switch (width) {
+ case 1:
+ *out = *(volatile uacpi_u8*)ptr;
+ break;
+ case 2:
+ *out = *(volatile uacpi_u16*)ptr;
+ break;
+ case 4:
+ *out = *(volatile uacpi_u32*)ptr;
+ break;
+ case 8:
+ *out = *(volatile uacpi_u64*)ptr;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_system_memory_write(
+ void *ptr, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+)
+{
+ ptr = UACPI_PTR_ADD(ptr, offset);
+
+ switch (width) {
+ case 1:
+ *(volatile uacpi_u8*)ptr = in;
+ break;
+ case 2:
+ *(volatile uacpi_u16*)ptr = in;
+ break;
+ case 4:
+ *(volatile uacpi_u32*)ptr = in;
+ break;
+ case 8:
+ *(volatile uacpi_u64*)ptr = in;
+ break;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+union integer_data {
+ uacpi_u8 byte;
+ uacpi_u16 word;
+ uacpi_u32 dword;
+ uacpi_u64 qword;
+};
+
+uacpi_status uacpi_system_io_read(
+ uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+)
+{
+ uacpi_status ret;
+ union integer_data data = {
+ .qword = 0,
+ };
+
+ switch (width) {
+ case 1:
+ ret = uacpi_kernel_io_read8(handle, offset, &data.byte);
+ break;
+ case 2:
+ ret = uacpi_kernel_io_read16(handle, offset, &data.word);
+ break;
+ case 4:
+ ret = uacpi_kernel_io_read32(handle, offset, &data.dword);
+ break;
+ default:
+ uacpi_error(
+ "invalid SystemIO read %p@%zu width=%d\n",
+ handle, offset, width
+ );
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_likely_success(ret))
+ *out = data.qword;
+ return ret;
+}
+
+uacpi_status uacpi_system_io_write(
+ uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+)
+{
+ uacpi_status ret;
+
+ switch (width) {
+ case 1:
+ ret = uacpi_kernel_io_write8(handle, offset, in);
+ break;
+ case 2:
+ ret = uacpi_kernel_io_write16(handle, offset, in);
+ break;
+ case 4:
+ ret = uacpi_kernel_io_write32(handle, offset, in);
+ break;
+ default:
+ uacpi_error(
+ "invalid SystemIO write %p@%zu width=%d\n",
+ handle, offset, width
+ );
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ret;
+}
+
+uacpi_status uacpi_pci_read(
+ uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 *out
+)
+{
+ uacpi_status ret;
+ union integer_data data = {
+ .qword = 0,
+ };
+
+ switch (width) {
+ case 1:
+ ret = uacpi_kernel_pci_read8(handle, offset, &data.byte);
+ break;
+ case 2:
+ ret = uacpi_kernel_pci_read16(handle, offset, &data.word);
+ break;
+ case 4:
+ ret = uacpi_kernel_pci_read32(handle, offset, &data.dword);
+ break;
+ default:
+ uacpi_error(
+ "invalid PCI_Config read %p@%zu width=%d\n",
+ handle, offset, width
+ );
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_likely_success(ret))
+ *out = data.qword;
+ return ret;
+}
+
+uacpi_status uacpi_pci_write(
+ uacpi_handle handle, uacpi_size offset, uacpi_u8 width, uacpi_u64 in
+)
+{
+ uacpi_status ret;
+
+ switch (width) {
+ case 1:
+ ret = uacpi_kernel_pci_write8(handle, offset, in);
+ break;
+ case 2:
+ ret = uacpi_kernel_pci_write16(handle, offset, in);
+ break;
+ case 4:
+ ret = uacpi_kernel_pci_write32(handle, offset, in);
+ break;
+ default:
+ uacpi_error(
+ "invalid PCI_Config write %p@%zu width=%d\n",
+ handle, offset, width
+ );
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/mutex.c b/sys/dev/acpi/uacpi/mutex.c
new file mode 100644
index 0000000..44cbac3
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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 3u
+
+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
diff --git a/sys/dev/acpi/uacpi/namespace.c b/sys/dev/acpi/uacpi/namespace.c
new file mode 100644
index 0000000..e847dea
--- /dev/null
+++ b/sys/dev/acpi/uacpi/namespace.c
@@ -0,0 +1,1081 @@
+#include <uacpi/namespace.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/types.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/kernel_api.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define UACPI_REV_VALUE 2
+#define UACPI_OS_VALUE "Microsoft Windows NT"
+
+#define MAKE_PREDEFINED(c0, c1, c2, c3) \
+ { \
+ .name.text = { c0, c1, c2, c3 }, \
+ .flags = UACPI_NAMESPACE_NODE_PREDEFINED \
+ }
+
+static uacpi_namespace_node
+predefined_namespaces[UACPI_PREDEFINED_NAMESPACE_MAX + 1] = {
+ [UACPI_PREDEFINED_NAMESPACE_ROOT] = MAKE_PREDEFINED('\\', 0, 0, 0),
+ [UACPI_PREDEFINED_NAMESPACE_GPE] = MAKE_PREDEFINED('_', 'G', 'P', 'E'),
+ [UACPI_PREDEFINED_NAMESPACE_PR] = MAKE_PREDEFINED('_', 'P', 'R', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_SB] = MAKE_PREDEFINED('_', 'S', 'B', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_SI] = MAKE_PREDEFINED('_', 'S', 'I', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_TZ] = MAKE_PREDEFINED('_', 'T', 'Z', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_GL] = MAKE_PREDEFINED('_', 'G', 'L', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_OS] = MAKE_PREDEFINED('_', 'O', 'S', '_'),
+ [UACPI_PREDEFINED_NAMESPACE_OSI] = MAKE_PREDEFINED('_', 'O', 'S', 'I'),
+ [UACPI_PREDEFINED_NAMESPACE_REV] = MAKE_PREDEFINED('_', 'R', 'E', 'V'),
+};
+
+static struct uacpi_rw_lock namespace_lock;
+
+uacpi_status uacpi_namespace_read_lock(void)
+{
+ return uacpi_rw_lock_read(&namespace_lock);
+}
+
+uacpi_status uacpi_namespace_read_unlock(void)
+{
+ return uacpi_rw_unlock_read(&namespace_lock);
+}
+
+uacpi_status uacpi_namespace_write_lock(void)
+{
+ return uacpi_rw_lock_write(&namespace_lock);
+}
+
+uacpi_status uacpi_namespace_write_unlock(void)
+{
+ return uacpi_rw_unlock_write(&namespace_lock);
+}
+
+static uacpi_object *make_object_for_predefined(
+ enum uacpi_predefined_namespace ns
+)
+{
+ uacpi_object *obj;
+
+ switch (ns) {
+ case UACPI_PREDEFINED_NAMESPACE_ROOT:
+ /*
+ * The real root object is stored in the global context, whereas the \
+ * node gets a placeholder uninitialized object instead. This is to
+ * protect against CopyObject(JUNK, \), so that all of the opregion and
+ * notify handlers are preserved if AML decides to do that.
+ */
+ g_uacpi_rt_ctx.root_object = uacpi_create_object(UACPI_OBJECT_DEVICE);
+ if (uacpi_unlikely(g_uacpi_rt_ctx.root_object == UACPI_NULL))
+ return UACPI_NULL;
+
+ obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ break;
+
+ case UACPI_PREDEFINED_NAMESPACE_OS:
+ obj = uacpi_create_object(UACPI_OBJECT_STRING);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ obj->buffer->text = uacpi_kernel_alloc(sizeof(UACPI_OS_VALUE));
+ if (uacpi_unlikely(obj->buffer->text == UACPI_NULL)) {
+ uacpi_object_unref(obj);
+ return UACPI_NULL;
+ }
+
+ obj->buffer->size = sizeof(UACPI_OS_VALUE);
+ uacpi_memcpy(obj->buffer->text, UACPI_OS_VALUE, obj->buffer->size);
+ break;
+
+ case UACPI_PREDEFINED_NAMESPACE_REV:
+ obj = uacpi_create_object(UACPI_OBJECT_INTEGER);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ obj->integer = UACPI_REV_VALUE;
+ break;
+
+ case UACPI_PREDEFINED_NAMESPACE_GL:
+ obj = uacpi_create_object(UACPI_OBJECT_MUTEX);
+ if (uacpi_likely(obj != UACPI_NULL)) {
+ uacpi_shareable_ref(obj->mutex);
+ g_uacpi_rt_ctx.global_lock_mutex = obj->mutex;
+ }
+ break;
+
+ case UACPI_PREDEFINED_NAMESPACE_OSI:
+ obj = uacpi_create_object(UACPI_OBJECT_METHOD);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ obj->method->native_call = UACPI_TRUE;
+ obj->method->handler = uacpi_osi;
+ obj->method->args = 1;
+ break;
+
+ default:
+ obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ break;
+ }
+
+ return obj;
+}
+
+static void namespace_node_detach_object(uacpi_namespace_node *node)
+{
+ uacpi_object *object;
+
+ object = uacpi_namespace_node_get_object(node);
+ if (object != UACPI_NULL) {
+ if (object->type == UACPI_OBJECT_OPERATION_REGION)
+ uacpi_opregion_uninstall_handler(node);
+
+ uacpi_object_unref(node->object);
+ node->object = UACPI_NULL;
+ }
+}
+
+static void free_namespace_node(uacpi_handle handle)
+{
+ uacpi_namespace_node *node = handle;
+
+ if (uacpi_likely(!uacpi_namespace_node_is_predefined(node))) {
+ uacpi_free(node, sizeof(*node));
+ return;
+ }
+
+ node->flags = UACPI_NAMESPACE_NODE_PREDEFINED;
+ node->object = UACPI_NULL;
+ node->parent = UACPI_NULL;
+ node->child = UACPI_NULL;
+ node->next = UACPI_NULL;
+}
+
+uacpi_status uacpi_initialize_namespace(void)
+{
+ enum uacpi_predefined_namespace ns;
+ uacpi_object *obj;
+ uacpi_namespace_node *node;
+ uacpi_status ret;
+
+ ret = uacpi_rw_lock_init(&namespace_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ for (ns = 0; ns <= UACPI_PREDEFINED_NAMESPACE_MAX; ns++) {
+ node = &predefined_namespaces[ns];
+ uacpi_shareable_init(node);
+
+ obj = make_object_for_predefined(ns);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ node->object = uacpi_create_internal_reference(
+ UACPI_REFERENCE_KIND_NAMED, obj
+ );
+ if (uacpi_unlikely(node->object == UACPI_NULL)) {
+ uacpi_object_unref(obj);
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ uacpi_object_unref(obj);
+ }
+
+ for (ns = UACPI_PREDEFINED_NAMESPACE_GPE;
+ ns <= UACPI_PREDEFINED_NAMESPACE_MAX; ns++) {
+
+ /*
+ * Skip the installation of \_OSI if it was disabled by user.
+ * We still create the object, but it's not attached to the namespace.
+ */
+ if (ns == UACPI_PREDEFINED_NAMESPACE_OSI &&
+ uacpi_check_flag(UACPI_FLAG_NO_OSI))
+ continue;
+
+ uacpi_namespace_node_install(
+ uacpi_namespace_root(), &predefined_namespaces[ns]
+ );
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+void uacpi_deinitialize_namespace(void)
+{
+ uacpi_status ret;
+ uacpi_namespace_node *current, *next = UACPI_NULL;
+ uacpi_u32 depth = 1;
+
+ current = uacpi_namespace_root();
+
+ ret = uacpi_namespace_write_lock();
+
+ while (depth) {
+ next = next == UACPI_NULL ? current->child : next->next;
+
+ /*
+ * The previous value of 'next' was the last child of this subtree,
+ * we can now remove the entire scope of 'current->child'
+ */
+ if (next == UACPI_NULL) {
+ depth--;
+
+ // Wipe the subtree
+ while (current->child != UACPI_NULL)
+ uacpi_namespace_node_uninstall(current->child);
+
+ // Reset the pointers back as if this iteration never happened
+ next = current;
+ current = current->parent;
+
+ continue;
+ }
+
+ /*
+ * We have more nodes to process, proceed to the next one, either the
+ * child of the 'next' node, if one exists, or its peer
+ */
+ if (next->child) {
+ depth++;
+ current = next;
+ next = UACPI_NULL;
+ }
+
+ // This node has no children, move on to its peer
+ }
+
+ namespace_node_detach_object(uacpi_namespace_root());
+ free_namespace_node(uacpi_namespace_root());
+
+ if (ret == UACPI_STATUS_OK)
+ uacpi_namespace_write_unlock();
+
+ uacpi_object_unref(g_uacpi_rt_ctx.root_object);
+ g_uacpi_rt_ctx.root_object = UACPI_NULL;
+
+ uacpi_mutex_unref(g_uacpi_rt_ctx.global_lock_mutex);
+ g_uacpi_rt_ctx.global_lock_mutex = UACPI_NULL;
+
+ uacpi_rw_lock_deinit(&namespace_lock);
+}
+
+uacpi_namespace_node *uacpi_namespace_root(void)
+{
+ return &predefined_namespaces[UACPI_PREDEFINED_NAMESPACE_ROOT];
+}
+
+uacpi_namespace_node *uacpi_namespace_get_predefined(
+ enum uacpi_predefined_namespace ns
+)
+{
+ if (uacpi_unlikely(ns > UACPI_PREDEFINED_NAMESPACE_MAX)) {
+ uacpi_warn("requested invalid predefined namespace %d\n", ns);
+ return UACPI_NULL;
+ }
+
+ return &predefined_namespaces[ns];
+}
+
+uacpi_namespace_node *uacpi_namespace_node_alloc(uacpi_object_name name)
+{
+ uacpi_namespace_node *ret;
+
+ ret = uacpi_kernel_alloc_zeroed(sizeof(*ret));
+ if (uacpi_unlikely(ret == UACPI_NULL))
+ return ret;
+
+ uacpi_shareable_init(ret);
+ ret->name = name;
+ return ret;
+}
+
+void uacpi_namespace_node_unref(uacpi_namespace_node *node)
+{
+ uacpi_shareable_unref_and_delete_if_last(node, free_namespace_node);
+}
+
+uacpi_status uacpi_namespace_node_install(
+ uacpi_namespace_node *parent,
+ uacpi_namespace_node *node
+)
+{
+ if (parent == UACPI_NULL)
+ parent = uacpi_namespace_root();
+
+ if (uacpi_unlikely(uacpi_namespace_node_is_dangling(node))) {
+ uacpi_warn("attempting to install a dangling namespace node %.4s\n",
+ node->name.text);
+ return UACPI_STATUS_NAMESPACE_NODE_DANGLING;
+ }
+
+ if (parent->child == UACPI_NULL) {
+ parent->child = node;
+ } else {
+ uacpi_namespace_node *prev = parent->child;
+
+ while (prev->next != UACPI_NULL)
+ prev = prev->next;
+
+ prev->next = node;
+ }
+
+ node->parent = parent;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_bool uacpi_namespace_node_is_alias(uacpi_namespace_node *node)
+{
+ return node->flags & UACPI_NAMESPACE_NODE_FLAG_ALIAS;
+}
+
+uacpi_bool uacpi_namespace_node_is_dangling(uacpi_namespace_node *node)
+{
+ return node->flags & UACPI_NAMESPACE_NODE_FLAG_DANGLING;
+}
+
+uacpi_bool uacpi_namespace_node_is_temporary(uacpi_namespace_node *node)
+{
+ return node->flags & UACPI_NAMESPACE_NODE_FLAG_TEMPORARY;
+}
+
+uacpi_bool uacpi_namespace_node_is_predefined(uacpi_namespace_node *node)
+{
+ return node->flags & UACPI_NAMESPACE_NODE_PREDEFINED;
+}
+
+uacpi_status uacpi_namespace_node_uninstall(uacpi_namespace_node *node)
+{
+ uacpi_namespace_node *prev;
+
+ if (uacpi_unlikely(uacpi_namespace_node_is_dangling(node))) {
+ uacpi_warn("attempting to uninstall a dangling namespace node %.4s\n",
+ node->name.text);
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ /*
+ * The way to trigger this is as follows:
+ *
+ * Method (FOO) {
+ * // Temporary device, will be deleted upon returning from FOO
+ * Device (\BAR) {
+ * }
+ *
+ * //
+ * // Load TBL where TBL is:
+ * // Scope (\BAR) {
+ * // Name (TEST, 123)
+ * // }
+ * //
+ * Load(TBL)
+ * }
+ *
+ * In the above example, TEST is a permanent node attached by bad AML to a
+ * temporary node created inside the FOO method at \BAR. The cleanup code
+ * will attempt to remove the \BAR device upon exit from FOO, but that is
+ * no longer possible as there's now a permanent child attached to it.
+ */
+ if (uacpi_unlikely(node->child != UACPI_NULL)) {
+ uacpi_warn(
+ "refusing to uninstall node %.4s with a child (%.4s)\n",
+ node->name.text, node->child->name.text
+ );
+ return UACPI_STATUS_DENIED;
+ }
+
+ /*
+ * Even though namespace_node is reference-counted it still has an 'invalid'
+ * state that is entered after it is uninstalled from the global namespace.
+ *
+ * Reference counting is only needed to combat dangling pointer issues
+ * whereas bad AML might try to prolong a local object lifetime by
+ * returning it from a method, or CopyObject it somewhere. In that case the
+ * namespace node object itself is still alive, but no longer has a valid
+ * object associated with it.
+ *
+ * Example:
+ * Method (BAD) {
+ * OperationRegion(REG, SystemMemory, 0xDEADBEEF, 4)
+ * Field (REG, AnyAcc, NoLock) {
+ * FILD, 8,
+ * }
+ *
+ * Return (RefOf(FILD))
+ * }
+ *
+ * // Local0 is now the sole owner of the 'FILD' object that under the
+ * // hood is still referencing the 'REG' operation region object from
+ * // the 'BAD' method.
+ * Local0 = DerefOf(BAD())
+ *
+ * This is done to prevent potential very deep recursion where an object
+ * frees a namespace node that frees an attached object that frees a
+ * namespace node as well as potential infinite cycles between a namespace
+ * node and an object.
+ */
+ namespace_node_detach_object(node);
+
+ prev = node->parent ? node->parent->child : UACPI_NULL;
+
+ if (prev == node) {
+ node->parent->child = node->next;
+ } else {
+ while (uacpi_likely(prev != UACPI_NULL) && prev->next != node)
+ prev = prev->next;
+
+ if (uacpi_unlikely(prev == UACPI_NULL)) {
+ uacpi_warn(
+ "trying to uninstall a node %.4s (%p) not linked to any peer\n",
+ node->name.text, node
+ );
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ prev->next = node->next;
+ }
+
+ node->flags |= UACPI_NAMESPACE_NODE_FLAG_DANGLING;
+ uacpi_namespace_node_unref(node);
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_namespace_node *uacpi_namespace_node_find_sub_node(
+ uacpi_namespace_node *parent,
+ uacpi_object_name name
+)
+{
+ uacpi_namespace_node *node;
+
+ if (parent == UACPI_NULL)
+ parent = uacpi_namespace_root();
+
+ node = parent->child;
+
+ while (node) {
+ if (node->name.id == name.id)
+ return node;
+
+ node = node->next;
+ }
+
+ return UACPI_NULL;
+}
+
+static uacpi_object_name segment_to_name(
+ const uacpi_char **string, uacpi_size *in_out_size
+)
+{
+ uacpi_object_name out_name;
+ const uacpi_char *cursor = *string;
+ uacpi_size offset, bytes_left = *in_out_size;
+
+ for (offset = 0; offset < 4; offset++) {
+ if (bytes_left < 1 || *cursor == '.') {
+ out_name.text[offset] = '_';
+ continue;
+ }
+
+ out_name.text[offset] = *cursor++;
+ bytes_left--;
+ }
+
+ *string = cursor;
+ *in_out_size = bytes_left;
+ return out_name;
+}
+
+uacpi_status uacpi_namespace_node_resolve(
+ uacpi_namespace_node *parent, const uacpi_char *path,
+ enum uacpi_should_lock should_lock,
+ enum uacpi_may_search_above_parent may_search_above_parent,
+ enum uacpi_permanent_only permanent_only,
+ uacpi_namespace_node **out_node
+)
+{
+ uacpi_namespace_node *cur_node = parent;
+ uacpi_status ret = UACPI_STATUS_OK;
+ const uacpi_char *cursor = path;
+ uacpi_size bytes_left;
+ uacpi_char prev_char = 0;
+ uacpi_bool single_nameseg = UACPI_TRUE;
+
+ if (cur_node == UACPI_NULL)
+ cur_node = uacpi_namespace_root();
+
+ bytes_left = uacpi_strlen(path);
+
+ if (should_lock == UACPI_SHOULD_LOCK_YES) {
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ for (;;) {
+ if (bytes_left == 0)
+ goto out;
+
+ switch (*cursor) {
+ case '\\':
+ single_nameseg = UACPI_FALSE;
+
+ if (prev_char == '^') {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ cur_node = uacpi_namespace_root();
+ break;
+ case '^':
+ single_nameseg = UACPI_FALSE;
+
+ // Tried to go behind root
+ if (uacpi_unlikely(cur_node == uacpi_namespace_root())) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ cur_node = cur_node->parent;
+ break;
+ default:
+ break;
+ }
+
+ prev_char = *cursor;
+
+ switch (prev_char) {
+ case '^':
+ case '\\':
+ cursor++;
+ bytes_left--;
+ break;
+ default:
+ break;
+ }
+
+ if (prev_char != '^')
+ break;
+ }
+
+ while (bytes_left != 0) {
+ uacpi_object_name nameseg;
+
+ if (*cursor == '.') {
+ cursor++;
+ bytes_left--;
+ }
+
+ nameseg = segment_to_name(&cursor, &bytes_left);
+ if (bytes_left != 0 && single_nameseg)
+ single_nameseg = UACPI_FALSE;
+
+ cur_node = uacpi_namespace_node_find_sub_node(cur_node, nameseg);
+ if (cur_node == UACPI_NULL) {
+ if (may_search_above_parent == UACPI_MAY_SEARCH_ABOVE_PARENT_NO ||
+ !single_nameseg)
+ goto out;
+
+ parent = parent->parent;
+
+ while (parent) {
+ cur_node = uacpi_namespace_node_find_sub_node(parent, nameseg);
+ if (cur_node != UACPI_NULL)
+ goto out;
+
+ parent = parent->parent;
+ }
+
+ goto out;
+ }
+ }
+
+out:
+ if (uacpi_unlikely(ret == UACPI_STATUS_INVALID_ARGUMENT)) {
+ uacpi_warn("invalid path '%s'\n", path);
+ goto out_read_unlock;
+ }
+
+ if (cur_node == UACPI_NULL) {
+ ret = UACPI_STATUS_NOT_FOUND;
+ goto out_read_unlock;
+ }
+
+ if (uacpi_namespace_node_is_temporary(cur_node) &&
+ permanent_only == UACPI_PERMANENT_ONLY_YES) {
+ uacpi_warn("denying access to temporary namespace node '%.4s'\n",
+ cur_node->name.text);
+ ret = UACPI_STATUS_DENIED;
+ goto out_read_unlock;
+ }
+
+ if (out_node != UACPI_NULL)
+ *out_node = cur_node;
+
+out_read_unlock:
+ if (should_lock == UACPI_SHOULD_LOCK_YES)
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+uacpi_status uacpi_namespace_node_find(
+ uacpi_namespace_node *parent, const uacpi_char *path,
+ uacpi_namespace_node **out_node
+)
+{
+ return uacpi_namespace_node_resolve(
+ parent, path, UACPI_SHOULD_LOCK_YES, UACPI_MAY_SEARCH_ABOVE_PARENT_NO,
+ UACPI_PERMANENT_ONLY_YES, out_node
+ );
+}
+
+uacpi_status uacpi_namespace_node_resolve_from_aml_namepath(
+ uacpi_namespace_node *scope,
+ const uacpi_char *path,
+ uacpi_namespace_node **out_node
+)
+{
+ return uacpi_namespace_node_resolve(
+ scope, path, UACPI_SHOULD_LOCK_YES, UACPI_MAY_SEARCH_ABOVE_PARENT_YES,
+ UACPI_PERMANENT_ONLY_YES, out_node
+ );
+}
+
+uacpi_object *uacpi_namespace_node_get_object(const uacpi_namespace_node *node)
+{
+ if (node == UACPI_NULL || node->object == UACPI_NULL)
+ return UACPI_NULL;
+
+ return uacpi_unwrap_internal_reference(node->object);
+}
+
+uacpi_object *uacpi_namespace_node_get_object_typed(
+ const uacpi_namespace_node *node, uacpi_object_type_bits type_mask
+)
+{
+ uacpi_object *obj;
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ if (!uacpi_object_is_one_of(obj, type_mask))
+ return UACPI_NULL;
+
+ return obj;
+}
+
+uacpi_status uacpi_namespace_node_acquire_object_typed(
+ const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+ uacpi_object **out_obj
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ obj = uacpi_namespace_node_get_object(node);
+
+ if (uacpi_unlikely(obj == UACPI_NULL) ||
+ !uacpi_object_is_one_of(obj, type_mask)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ uacpi_object_ref(obj);
+ *out_obj = obj;
+
+out:
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+uacpi_status uacpi_namespace_node_acquire_object(
+ const uacpi_namespace_node *node, uacpi_object **out_obj
+)
+{
+ return uacpi_namespace_node_acquire_object_typed(
+ node, UACPI_OBJECT_ANY_BIT, out_obj
+ );
+}
+
+enum action {
+ ACTION_REACQUIRE,
+ ACTION_PUT,
+};
+
+static uacpi_status object_mutate_refcount(
+ uacpi_object *obj, void (*cb)(uacpi_object*)
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (uacpi_likely(!uacpi_object_is(obj, UACPI_OBJECT_REFERENCE))) {
+ cb(obj);
+ return ret;
+ }
+
+ /*
+ * Reference objects must be (un)referenced under at least a read lock, as
+ * this requires walking down the entire reference chain and dropping each
+ * object ref-count by 1. This might race with the interpreter and
+ * object_replace_child in case an object in the chain is CopyObject'ed
+ * into.
+ */
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ cb(obj);
+
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+uacpi_status uacpi_namespace_node_reacquire_object(
+ uacpi_object *obj
+)
+{
+ return object_mutate_refcount(obj, uacpi_object_ref);
+}
+
+uacpi_status uacpi_namespace_node_release_object(uacpi_object *obj)
+{
+ return object_mutate_refcount(obj, uacpi_object_unref);
+}
+
+uacpi_object_name uacpi_namespace_node_name(const uacpi_namespace_node *node)
+{
+ return node->name;
+}
+
+uacpi_status uacpi_namespace_node_type_unlocked(
+ const uacpi_namespace_node *node, uacpi_object_type *out_type
+)
+{
+ uacpi_object *obj;
+
+ if (uacpi_unlikely(node == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_NOT_FOUND;
+
+ *out_type = obj->type;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_namespace_node_type(
+ const uacpi_namespace_node *node, uacpi_object_type *out_type
+)
+{
+ uacpi_status ret;
+
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_namespace_node_type_unlocked(node, out_type);
+
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+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 *obj;
+
+ if (uacpi_unlikely(node == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_NOT_FOUND;
+
+ *out = uacpi_object_is_one_of(obj, type_mask);
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_namespace_node_is_one_of(
+ const uacpi_namespace_node *node, uacpi_object_type_bits type_mask,
+ uacpi_bool *out
+)
+{
+ uacpi_status ret;
+
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_namespace_node_is_one_of_unlocked(node,type_mask, out);
+
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+uacpi_status uacpi_namespace_node_is(
+ const uacpi_namespace_node *node, uacpi_object_type type, uacpi_bool *out
+)
+{
+ return uacpi_namespace_node_is_one_of(
+ node, 1u << type, out
+ );
+}
+
+uacpi_status uacpi_namespace_do_for_each_child(
+ uacpi_namespace_node *node, uacpi_iteration_callback descending_callback,
+ uacpi_iteration_callback ascending_callback,
+ uacpi_object_type_bits type_mask, uacpi_u32 max_depth,
+ enum uacpi_should_lock should_lock,
+ enum uacpi_permanent_only permanent_only, void *user
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ uacpi_iteration_decision decision;
+ uacpi_iteration_callback cb;
+ uacpi_bool walking_up = UACPI_FALSE, matches = UACPI_FALSE;
+ uacpi_u32 depth = 1;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(descending_callback == UACPI_NULL &&
+ ascending_callback == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (uacpi_unlikely(node == UACPI_NULL || max_depth == 0))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (should_lock == UACPI_SHOULD_LOCK_YES) {
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ if (node->child == UACPI_NULL)
+ goto out;
+
+ node = node->child;
+
+ while (depth) {
+ uacpi_namespace_node_is_one_of_unlocked(node, type_mask, &matches);
+ if (!matches) {
+ decision = UACPI_ITERATION_DECISION_CONTINUE;
+ goto do_next;
+ }
+
+ if (permanent_only == UACPI_PERMANENT_ONLY_YES &&
+ uacpi_namespace_node_is_temporary(node)) {
+ decision = UACPI_ITERATION_DECISION_NEXT_PEER;
+ goto do_next;
+ }
+
+ cb = walking_up ? ascending_callback : descending_callback;
+ if (cb != UACPI_NULL) {
+ if (should_lock == UACPI_SHOULD_LOCK_YES) {
+ ret = uacpi_namespace_read_unlock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ decision = cb(user, node, depth);
+ if (decision == UACPI_ITERATION_DECISION_BREAK)
+ return ret;
+
+ if (should_lock == UACPI_SHOULD_LOCK_YES) {
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+ } else {
+ decision = UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ do_next:
+ if (walking_up) {
+ if (node->next) {
+ node = node->next;
+ walking_up = UACPI_FALSE;
+ continue;
+ }
+
+ depth--;
+ node = node->parent;
+ continue;
+ }
+
+ switch (decision) {
+ case UACPI_ITERATION_DECISION_CONTINUE:
+ if ((depth != max_depth) && (node->child != UACPI_NULL)) {
+ node = node->child;
+ depth++;
+ continue;
+ }
+ UACPI_FALLTHROUGH;
+ case UACPI_ITERATION_DECISION_NEXT_PEER:
+ walking_up = UACPI_TRUE;
+ continue;
+ default:
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+ }
+
+out:
+ if (should_lock == UACPI_SHOULD_LOCK_YES)
+ uacpi_namespace_read_unlock();
+ return ret;
+}
+
+uacpi_status uacpi_namespace_for_each_child_simple(
+ uacpi_namespace_node *parent, uacpi_iteration_callback callback, void *user
+)
+{
+ return uacpi_namespace_do_for_each_child(
+ parent, callback, UACPI_NULL, UACPI_OBJECT_ANY_BIT, UACPI_MAX_DEPTH_ANY,
+ UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, user
+ );
+}
+
+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
+)
+{
+ return uacpi_namespace_do_for_each_child(
+ parent, descending_callback, ascending_callback, type_mask, max_depth,
+ UACPI_SHOULD_LOCK_YES, UACPI_PERMANENT_ONLY_YES, user
+ );
+}
+
+uacpi_status uacpi_namespace_node_next_typed(
+ uacpi_namespace_node *parent, uacpi_namespace_node **iter,
+ uacpi_object_type_bits type_mask
+)
+{
+ uacpi_status ret;
+ uacpi_bool is_one_of;
+ uacpi_namespace_node *node;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED);
+
+ if (uacpi_unlikely(parent == UACPI_NULL && *iter == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_namespace_read_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ node = *iter;
+ if (node == UACPI_NULL)
+ node = parent->child;
+ else
+ node = node->next;
+
+ for (; node != UACPI_NULL; node = node->next) {
+ if (uacpi_namespace_node_is_temporary(node))
+ continue;
+
+ ret = uacpi_namespace_node_is_one_of_unlocked(
+ node, type_mask, &is_one_of
+ );
+ if (uacpi_unlikely_error(ret))
+ break;
+ if (is_one_of)
+ break;
+ }
+
+ uacpi_namespace_read_unlock();
+ if (node == UACPI_NULL)
+ return UACPI_STATUS_NOT_FOUND;
+
+ if (uacpi_likely_success(ret))
+ *iter = node;
+ return ret;
+}
+
+uacpi_status uacpi_namespace_node_next(
+ uacpi_namespace_node *parent, uacpi_namespace_node **iter
+)
+{
+ return uacpi_namespace_node_next_typed(
+ parent, iter, UACPI_OBJECT_ANY_BIT
+ );
+}
+
+uacpi_size uacpi_namespace_node_depth(const uacpi_namespace_node *node)
+{
+ uacpi_size depth = 0;
+
+ while (node->parent) {
+ depth++;
+ node = node->parent;
+ }
+
+ return depth;
+}
+
+uacpi_namespace_node *uacpi_namespace_node_parent(
+ uacpi_namespace_node *node
+)
+{
+ return node->parent;
+}
+
+const uacpi_char *uacpi_namespace_node_generate_absolute_path(
+ const uacpi_namespace_node *node
+)
+{
+ uacpi_size depth, offset;
+ uacpi_size bytes_needed;
+ uacpi_char *path;
+
+ depth = uacpi_namespace_node_depth(node) + 1;
+
+ // \ only needs 1 byte, the rest is 4 bytes
+ bytes_needed = 1 + (depth - 1) * sizeof(uacpi_object_name);
+
+ // \ and the first NAME don't need a '.', every other segment does
+ bytes_needed += depth > 2 ? depth - 2 : 0;
+
+ // Null terminator
+ bytes_needed += 1;
+
+ path = uacpi_kernel_alloc(bytes_needed);
+ if (uacpi_unlikely(path == UACPI_NULL))
+ return path;
+
+ path[0] = '\\';
+
+ offset = bytes_needed - 1;
+ path[offset] = '\0';
+
+ while (node != uacpi_namespace_root()) {
+ offset -= sizeof(uacpi_object_name);
+ uacpi_memcpy(&path[offset], node->name.text, sizeof(uacpi_object_name));
+
+ node = node->parent;
+ if (node != uacpi_namespace_root())
+ path[--offset] = '.';
+ }
+
+ return path;
+}
+
+void uacpi_free_absolute_path(const uacpi_char *path)
+{
+ uacpi_free_dynamic_string(path);
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/notify.c b/sys/dev/acpi/uacpi/notify.c
new file mode 100644
index 0000000..b413df9
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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
diff --git a/sys/dev/acpi/uacpi/opcodes.c b/sys/dev/acpi/uacpi/opcodes.c
new file mode 100644
index 0000000..3665631
--- /dev/null
+++ b/sys/dev/acpi/uacpi/opcodes.c
@@ -0,0 +1,272 @@
+#include <uacpi/internal/opcodes.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define UACPI_OP(opname, opcode, props, ...) \
+ { #opname, { .decode_ops = __VA_ARGS__ }, .properties = props, .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
diff --git a/sys/dev/acpi/uacpi/opregion.c b/sys/dev/acpi/uacpi/opregion.c
new file mode 100644
index 0000000..ec0bc37
--- /dev/null
+++ b/sys/dev/acpi/uacpi/opregion.c
@@ -0,0 +1,1056 @@
+#include <uacpi/kernel_api.h>
+
+#include <uacpi/internal/opregion.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/mutex.h>
+#include <uacpi/internal/interpreter.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+struct uacpi_recursive_lock g_opregion_lock;
+
+uacpi_status uacpi_initialize_opregion(void)
+{
+ return uacpi_recursive_lock_init(&g_opregion_lock);
+}
+
+void uacpi_deinitialize_opregion(void)
+{
+ uacpi_recursive_lock_deinit(&g_opregion_lock);
+}
+
+void uacpi_trace_region_error(
+ uacpi_namespace_node *node, uacpi_char *message, uacpi_status ret
+)
+{
+ const uacpi_char *path, *space_string = "<unknown>";
+ uacpi_object *obj;
+
+ path = uacpi_namespace_node_generate_absolute_path(node);
+
+ obj = uacpi_namespace_node_get_object_typed(
+ node, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_likely(obj != UACPI_NULL))
+ space_string = uacpi_address_space_to_string(obj->op_region->space);
+
+ uacpi_error(
+ "%s (%s) operation region %s: %s\n",
+ message, space_string, path, uacpi_status_to_string(ret)
+ );
+ uacpi_free_dynamic_string(path);
+}
+
+static void trace_region_io(
+ uacpi_field_unit *field, uacpi_address_space space, uacpi_u64 offset,
+ uacpi_region_op op, union uacpi_opregion_io_data data
+)
+{
+ const uacpi_char *path;
+ const uacpi_char *type_str;
+
+ if (!uacpi_should_log(UACPI_LOG_TRACE))
+ return;
+
+ switch (op) {
+ case UACPI_REGION_OP_READ:
+ type_str = "read from";
+ break;
+ case UACPI_REGION_OP_WRITE:
+ type_str = "write to";
+ break;
+ default:
+ type_str = "<INVALID-OP>";
+ }
+
+ path = uacpi_namespace_node_generate_absolute_path(field->region);
+
+ switch (space) {
+ case UACPI_ADDRESS_SPACE_IPMI:
+ case UACPI_ADDRESS_SPACE_PRM:
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ uacpi_trace(
+ "write-then-read from [%s] %s[0x%016"UACPI_PRIX64"] = "
+ "<buffer of %zu bytes>\n", path,
+ uacpi_address_space_to_string(space),
+ UACPI_FMT64(offset), data.buffer.length
+ );
+ break;
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ uacpi_trace(
+ "%s [%s] %s[0x%016"UACPI_PRIX64"] = "
+ "<buffer of %zu bytes>\n", type_str, path,
+ uacpi_address_space_to_string(space),
+ UACPI_FMT64(offset), data.buffer.length
+ );
+ break;
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ uacpi_trace(
+ "%s [%s] %s pins[%u..%u] = 0x%"UACPI_PRIX64"\n",
+ type_str, path, uacpi_address_space_to_string(space),
+ field->pin_offset, (field->pin_offset + field->bit_length) - 1,
+ UACPI_FMT64(*data.integer)
+ );
+ break;
+ default:
+ uacpi_trace(
+ "%s [%s] (%d bytes) %s[0x%016"UACPI_PRIX64"] = 0x%"UACPI_PRIX64"\n",
+ type_str, path, field->access_width_bytes,
+ uacpi_address_space_to_string(space),
+ UACPI_FMT64(offset), UACPI_FMT64(*data.integer)
+ );
+ break;
+ }
+
+ uacpi_free_dynamic_string(path);
+}
+
+static uacpi_bool space_needs_reg(enum uacpi_address_space space)
+{
+ if (space == UACPI_ADDRESS_SPACE_SYSTEM_MEMORY ||
+ space == UACPI_ADDRESS_SPACE_SYSTEM_IO ||
+ space == UACPI_ADDRESS_SPACE_TABLE_DATA)
+ return UACPI_FALSE;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_status region_run_reg(
+ uacpi_namespace_node *node, uacpi_u8 connection_code
+)
+{
+ uacpi_status ret;
+ uacpi_namespace_node *reg_node;
+ uacpi_object_array method_args;
+ uacpi_object *reg_obj, *args[2];
+
+ ret = uacpi_namespace_node_resolve(
+ node->parent, "_REG", UACPI_SHOULD_LOCK_NO,
+ UACPI_MAY_SEARCH_ABOVE_PARENT_NO, UACPI_PERMANENT_ONLY_NO, &reg_node
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ reg_obj = uacpi_namespace_node_get_object_typed(
+ reg_node, UACPI_OBJECT_METHOD_BIT
+ );
+ if (uacpi_unlikely(reg_obj == UACPI_NULL))
+ return UACPI_STATUS_OK;
+
+ args[0] = uacpi_create_object(UACPI_OBJECT_INTEGER);
+ if (uacpi_unlikely(args[0] == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ args[1] = uacpi_create_object(UACPI_OBJECT_INTEGER);
+ if (uacpi_unlikely(args[1] == UACPI_NULL)) {
+ uacpi_object_unref(args[0]);
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ args[0]->integer = uacpi_namespace_node_get_object(node)->op_region->space;
+ args[1]->integer = connection_code;
+ method_args.objects = args;
+ method_args.count = 2;
+
+ ret = uacpi_execute_control_method(
+ reg_node, reg_obj->method, &method_args, UACPI_NULL
+ );
+ if (uacpi_unlikely_error(ret))
+ uacpi_trace_region_error(node, "error during _REG execution for", ret);
+
+ uacpi_object_unref(args[0]);
+ uacpi_object_unref(args[1]);
+ return ret;
+}
+
+uacpi_address_space_handlers *uacpi_node_get_address_space_handlers(
+ uacpi_namespace_node *node
+)
+{
+ uacpi_object *object;
+
+ if (node == uacpi_namespace_root())
+ return g_uacpi_rt_ctx.root_object->address_space_handlers;
+
+ object = uacpi_namespace_node_get_object(node);
+ if (uacpi_unlikely(object == UACPI_NULL))
+ return UACPI_NULL;
+
+ switch (object->type) {
+ case UACPI_OBJECT_DEVICE:
+ case UACPI_OBJECT_PROCESSOR:
+ case UACPI_OBJECT_THERMAL_ZONE:
+ return object->address_space_handlers;
+ default:
+ return UACPI_NULL;
+ }
+}
+
+static uacpi_address_space_handler *find_handler(
+ uacpi_address_space_handlers *handlers,
+ enum uacpi_address_space space
+)
+{
+ uacpi_address_space_handler *handler = handlers->head;
+
+ while (handler) {
+ if (handler->space == space)
+ return handler;
+
+ handler = handler->next;
+ }
+
+ return UACPI_NULL;
+}
+
+static uacpi_operation_region *find_previous_region_link(
+ uacpi_operation_region *region
+)
+{
+ uacpi_address_space_handler *handler = region->handler;
+ uacpi_operation_region *parent = handler->regions;
+
+ if (parent == region)
+ // This is the last attached region, it has no previous link
+ return region;
+
+ while (parent->next != region) {
+ parent = parent->next;
+
+ if (uacpi_unlikely(parent == UACPI_NULL))
+ return UACPI_NULL;
+ }
+
+ return parent;
+}
+
+uacpi_status uacpi_opregion_attach(uacpi_namespace_node *node)
+{
+ uacpi_object *obj;
+ uacpi_operation_region *region;
+ uacpi_address_space_handler *handler;
+ uacpi_status ret;
+ uacpi_region_attach_data attach_data = { 0 };
+
+ if (uacpi_namespace_node_is_dangling(node))
+ return UACPI_STATUS_NAMESPACE_NODE_DANGLING;
+
+ obj = uacpi_namespace_node_get_object_typed(
+ node, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ region = obj->op_region;
+
+ if (region->handler == UACPI_NULL)
+ return UACPI_STATUS_NO_HANDLER;
+ if (region->state_flags & UACPI_OP_REGION_STATE_ATTACHED)
+ return UACPI_STATUS_OK;
+
+ handler = region->handler;
+ attach_data.region_node = node;
+
+ switch (region->space) {
+ case UACPI_ADDRESS_SPACE_PCC:
+ if (region->length) {
+ region->internal_buffer = uacpi_kernel_alloc_zeroed(region->length);
+ if (uacpi_unlikely(region->internal_buffer == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ attach_data.pcc_info.buffer.bytes = region->internal_buffer;
+ attach_data.pcc_info.buffer.length = region->length;
+ attach_data.pcc_info.subspace_id = region->offset;
+ break;
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ attach_data.gpio_info.num_pins = region->length;
+ break;
+ default:
+ attach_data.generic_info.base = region->offset;
+ attach_data.generic_info.length = region->length;
+ break;
+ }
+
+ attach_data.handler_context = handler->user_context;
+
+ uacpi_object_ref(obj);
+ uacpi_namespace_write_unlock();
+ ret = handler->callback(UACPI_REGION_OP_ATTACH, &attach_data);
+ uacpi_namespace_write_lock();
+
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_object_unref(obj);
+ return ret;
+ }
+
+ region->state_flags |= UACPI_OP_REGION_STATE_ATTACHED;
+ region->user_context = attach_data.out_region_context;
+ uacpi_object_unref(obj);
+ return ret;
+}
+
+static void region_install_handler(
+ uacpi_namespace_node *node, uacpi_address_space_handler *handler
+)
+{
+ uacpi_operation_region *region;
+
+ region = uacpi_namespace_node_get_object(node)->op_region;
+ region->handler = handler;
+ uacpi_shareable_ref(handler);
+
+ region->next = handler->regions;
+ handler->regions = region;
+}
+
+enum unreg {
+ UNREG_NO = 0,
+ UNREG_YES,
+};
+
+static void region_uninstall_handler(
+ uacpi_namespace_node *node, enum unreg unreg
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ uacpi_address_space_handler *handler;
+ uacpi_operation_region *region, *link;
+
+ obj = uacpi_namespace_node_get_object_typed(
+ node, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return;
+
+ region = obj->op_region;
+
+ handler = region->handler;
+ if (handler == UACPI_NULL)
+ return;
+
+ link = find_previous_region_link(region);
+ if (uacpi_unlikely(link == UACPI_NULL)) {
+ uacpi_error("operation region @%p not in the handler@%p list(?)\n",
+ region, handler);
+ goto out;
+ } else if (link == region) {
+ link = link->next;
+ handler->regions = link;
+ } else {
+ link->next = region->next;
+ }
+
+out:
+ if (region->state_flags & UACPI_OP_REGION_STATE_ATTACHED) {
+ uacpi_region_detach_data detach_data = { 0 };
+
+ detach_data.region_node = node;
+ detach_data.region_context = region->user_context;
+ detach_data.handler_context = handler->user_context;
+
+ uacpi_shareable_ref(node);
+ uacpi_namespace_write_unlock();
+
+ ret = handler->callback(UACPI_REGION_OP_DETACH, &detach_data);
+
+ uacpi_namespace_write_lock();
+ uacpi_namespace_node_unref(node);
+
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_trace_region_error(
+ node, "error during handler detach for", ret
+ );
+ }
+ }
+
+ if ((region->state_flags & UACPI_OP_REGION_STATE_REG_EXECUTED) &&
+ unreg == UNREG_YES) {
+ region_run_reg(node, ACPI_REG_DISCONNECT);
+ region->state_flags &= ~UACPI_OP_REGION_STATE_REG_EXECUTED;
+ }
+
+ uacpi_address_space_handler_unref(region->handler);
+ region->handler = UACPI_NULL;
+ region->state_flags &= ~UACPI_OP_REGION_STATE_ATTACHED;
+}
+
+static uacpi_status upgrade_to_opregion_lock(void)
+{
+ uacpi_status ret;
+
+ /*
+ * Drop the namespace lock, and reacquire it after the opregion lock
+ * so we keep the ordering with user API.
+ */
+ uacpi_namespace_write_unlock();
+
+ ret = uacpi_recursive_lock_acquire(&g_opregion_lock);
+ uacpi_namespace_write_lock();
+ return ret;
+}
+
+void uacpi_opregion_uninstall_handler(uacpi_namespace_node *node)
+{
+ if (uacpi_unlikely_error(upgrade_to_opregion_lock()))
+ return;
+
+ region_uninstall_handler(node, UNREG_YES);
+
+ uacpi_recursive_lock_release(&g_opregion_lock);
+}
+
+uacpi_bool uacpi_address_space_handler_is_default(
+ uacpi_address_space_handler *handler
+)
+{
+ return handler->flags & UACPI_ADDRESS_SPACE_HANDLER_DEFAULT;
+}
+
+enum opregion_iter_action {
+ OPREGION_ITER_ACTION_UNINSTALL,
+ OPREGION_ITER_ACTION_INSTALL,
+};
+
+struct opregion_iter_ctx {
+ enum opregion_iter_action action;
+ uacpi_address_space_handler *handler;
+};
+
+static uacpi_iteration_decision do_install_or_uninstall_handler(
+ uacpi_handle opaque, uacpi_namespace_node *node, uacpi_u32 depth
+)
+{
+ struct opregion_iter_ctx *ctx = opaque;
+ uacpi_address_space_handlers *handlers;
+ uacpi_object *object;
+
+ UACPI_UNUSED(depth);
+
+ object = uacpi_namespace_node_get_object(node);
+ if (object->type == UACPI_OBJECT_OPERATION_REGION) {
+ uacpi_operation_region *region = object->op_region;
+
+ if (region->space != ctx->handler->space)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ if (ctx->action == OPREGION_ITER_ACTION_INSTALL) {
+ if (region->handler)
+ region_uninstall_handler(node, UNREG_NO);
+
+ region_install_handler(node, ctx->handler);
+ } else {
+ if (uacpi_unlikely(region->handler != ctx->handler)) {
+ uacpi_trace_region_error(
+ node, "handler mismatch for",
+ UACPI_STATUS_INTERNAL_ERROR
+ );
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ region_uninstall_handler(node, UNREG_NO);
+ }
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ handlers = uacpi_node_get_address_space_handlers(node);
+ if (handlers == UACPI_NULL)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ // Device already has a handler for this space installed
+ if (find_handler(handlers, ctx->handler->space) != UACPI_NULL)
+ return UACPI_ITERATION_DECISION_NEXT_PEER;
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+struct reg_run_ctx {
+ uacpi_u8 space;
+ uacpi_u8 connection_code;
+ uacpi_size reg_executed;
+ uacpi_size reg_errors;
+};
+
+static uacpi_iteration_decision do_run_reg(
+ void *opaque, uacpi_namespace_node *node, uacpi_u32 depth
+)
+{
+ struct reg_run_ctx *ctx = opaque;
+ uacpi_operation_region *region;
+ uacpi_status ret;
+ uacpi_bool was_regged;
+
+ UACPI_UNUSED(depth);
+
+ region = uacpi_namespace_node_get_object(node)->op_region;
+
+ if (region->space != ctx->space)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ was_regged = region->state_flags & UACPI_OP_REGION_STATE_REG_EXECUTED;
+ if (was_regged == (ctx->connection_code == ACPI_REG_CONNECT))
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ ret = region_run_reg(node, ctx->connection_code);
+ if (ctx->connection_code == ACPI_REG_DISCONNECT)
+ region->state_flags &= ~UACPI_OP_REGION_STATE_REG_EXECUTED;
+
+ if (ret == UACPI_STATUS_NOT_FOUND)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ if (ctx->connection_code == ACPI_REG_CONNECT)
+ region->state_flags |= UACPI_OP_REGION_STATE_REG_EXECUTED;
+
+ ctx->reg_executed++;
+
+ if (uacpi_unlikely_error(ret)) {
+ ctx->reg_errors++;
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ }
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+static uacpi_status reg_or_unreg_all_opregions(
+ uacpi_namespace_node *device_node, enum uacpi_address_space space,
+ uacpi_u8 connection_code
+)
+{
+ uacpi_address_space_handlers *handlers;
+ uacpi_bool is_connect;
+ enum uacpi_permanent_only perm_only;
+ struct reg_run_ctx ctx = { 0 };
+
+ ctx.space = space;
+ ctx.connection_code = connection_code;
+
+ handlers = uacpi_node_get_address_space_handlers(device_node);
+ if (uacpi_unlikely(handlers == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ is_connect = connection_code == ACPI_REG_CONNECT;
+ if (uacpi_unlikely(is_connect &&
+ find_handler(handlers, space) == UACPI_NULL))
+ return UACPI_STATUS_NO_HANDLER;
+
+ /*
+ * We want to unreg non-permanent opregions as well, however,
+ * registering them is handled separately and should not be
+ * done by us.
+ */
+ perm_only = is_connect ? UACPI_PERMANENT_ONLY_YES : UACPI_PERMANENT_ONLY_NO;
+
+ uacpi_namespace_do_for_each_child(
+ device_node, do_run_reg, UACPI_NULL,
+ UACPI_OBJECT_OPERATION_REGION_BIT, UACPI_MAX_DEPTH_ANY,
+ UACPI_SHOULD_LOCK_NO, perm_only, &ctx
+ );
+
+ uacpi_trace(
+ "%sactivated all '%s' opregions controlled by '%.4s', "
+ "%zu _REG() calls (%zu errors)\n",
+ connection_code == ACPI_REG_CONNECT ? "" : "de",
+ uacpi_address_space_to_string(space),
+ device_node->name.text, ctx.reg_executed, ctx.reg_errors
+ );
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_address_space_handlers *extract_handlers(
+ uacpi_namespace_node *node
+)
+{
+ uacpi_object *handlers_obj;
+
+ if (node == uacpi_namespace_root())
+ return g_uacpi_rt_ctx.root_object->address_space_handlers;
+
+ handlers_obj = uacpi_namespace_node_get_object_typed(
+ node,
+ UACPI_OBJECT_DEVICE_BIT | UACPI_OBJECT_THERMAL_ZONE_BIT |
+ UACPI_OBJECT_PROCESSOR_BIT
+ );
+ if (uacpi_unlikely(handlers_obj == UACPI_NULL))
+ return UACPI_NULL;
+
+ return handlers_obj->address_space_handlers;
+}
+
+uacpi_status uacpi_reg_all_opregions(
+ uacpi_namespace_node *device_node,
+ enum uacpi_address_space space
+)
+{
+ uacpi_status ret;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ if (!space_needs_reg(space))
+ return UACPI_STATUS_OK;
+
+ ret = uacpi_recursive_lock_acquire(&g_opregion_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_namespace_write_lock();
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+ }
+
+ if (uacpi_unlikely(extract_handlers(device_node) == UACPI_NULL)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ ret = reg_or_unreg_all_opregions(device_node, space, ACPI_REG_CONNECT);
+
+out:
+ uacpi_namespace_write_unlock();
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return 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
+)
+{
+ uacpi_status ret;
+ uacpi_address_space_handlers *handlers;
+ uacpi_address_space_handler *this_handler, *new_handler;
+ struct opregion_iter_ctx iter_ctx;
+
+ ret = uacpi_recursive_lock_acquire(&g_opregion_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_namespace_write_lock();
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+ }
+
+ handlers = extract_handlers(device_node);
+ if (uacpi_unlikely(handlers == UACPI_NULL)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ this_handler = find_handler(handlers, space);
+ if (this_handler != UACPI_NULL) {
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out;
+ }
+
+ new_handler = uacpi_kernel_alloc(sizeof(*new_handler));
+ if (new_handler == UACPI_NULL) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+ uacpi_shareable_init(new_handler);
+
+ new_handler->next = handlers->head;
+ new_handler->space = space;
+ new_handler->user_context = handler_context;
+ new_handler->callback = handler;
+ new_handler->regions = UACPI_NULL;
+ new_handler->flags = flags;
+ handlers->head = new_handler;
+
+ iter_ctx.handler = new_handler;
+ iter_ctx.action = OPREGION_ITER_ACTION_INSTALL;
+
+ uacpi_namespace_do_for_each_child(
+ device_node, do_install_or_uninstall_handler, UACPI_NULL,
+ UACPI_OBJECT_ANY_BIT, UACPI_MAX_DEPTH_ANY, UACPI_SHOULD_LOCK_NO,
+ UACPI_PERMANENT_ONLY_YES, &iter_ctx
+ );
+
+ if (!space_needs_reg(space))
+ goto out;
+
+ /*
+ * Installing an early address space handler, obviously not possible to
+ * execute any _REG methods here. Just return and hope that it is either
+ * a global address space handler, or a handler installed by a user who
+ * will run uacpi_reg_all_opregions manually after loading/initializing
+ * the namespace.
+ */
+ if (g_uacpi_rt_ctx.init_level < UACPI_INIT_LEVEL_NAMESPACE_LOADED)
+ goto out;
+
+ // Init level is NAMESPACE_INITIALIZED, so we can safely run _REG now
+ ret = reg_or_unreg_all_opregions(
+ device_node, space, ACPI_REG_CONNECT
+ );
+
+out:
+ uacpi_namespace_write_unlock();
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+}
+
+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
+)
+{
+ return uacpi_install_address_space_handler_with_flags(
+ device_node, space, handler, handler_context, 0
+ );
+}
+
+uacpi_status uacpi_uninstall_address_space_handler(
+ uacpi_namespace_node *device_node,
+ enum uacpi_address_space space
+)
+{
+ uacpi_status ret;
+ uacpi_address_space_handlers *handlers;
+ uacpi_address_space_handler *handler = UACPI_NULL, *prev_handler;
+ struct opregion_iter_ctx iter_ctx;
+
+ ret = uacpi_recursive_lock_acquire(&g_opregion_lock);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_namespace_write_lock();
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+ }
+
+ handlers = extract_handlers(device_node);
+ if (uacpi_unlikely(handlers == UACPI_NULL)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ handler = find_handler(handlers, space);
+ if (uacpi_unlikely(handler == UACPI_NULL)) {
+ ret = UACPI_STATUS_NO_HANDLER;
+ goto out;
+ }
+
+ iter_ctx.handler = handler;
+ iter_ctx.action = OPREGION_ITER_ACTION_UNINSTALL;
+
+ uacpi_namespace_do_for_each_child(
+ device_node, do_install_or_uninstall_handler, UACPI_NULL,
+ UACPI_OBJECT_ANY_BIT, UACPI_MAX_DEPTH_ANY, UACPI_SHOULD_LOCK_NO,
+ UACPI_PERMANENT_ONLY_NO, &iter_ctx
+ );
+
+ prev_handler = handlers->head;
+
+ // Are we the last linked handler?
+ if (prev_handler == handler) {
+ handlers->head = handler->next;
+ goto out_unreg;
+ }
+
+ // Nope, we're somewhere in the middle. Do a search.
+ while (prev_handler) {
+ if (prev_handler->next == handler) {
+ prev_handler->next = handler->next;
+ goto out;
+ }
+
+ prev_handler = prev_handler->next;
+ }
+
+out_unreg:
+ if (space_needs_reg(space))
+ reg_or_unreg_all_opregions(device_node, space, ACPI_REG_DISCONNECT);
+
+out:
+ if (handler != UACPI_NULL)
+ uacpi_address_space_handler_unref(handler);
+
+ uacpi_namespace_write_unlock();
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+}
+
+uacpi_status uacpi_initialize_opregion_node(uacpi_namespace_node *node)
+{
+ uacpi_status ret;
+ uacpi_namespace_node *parent = node->parent;
+ uacpi_operation_region *region;
+ uacpi_address_space_handlers *handlers;
+ uacpi_address_space_handler *handler;
+
+ ret = upgrade_to_opregion_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ region = uacpi_namespace_node_get_object(node)->op_region;
+ ret = UACPI_STATUS_NOT_FOUND;
+
+ while (parent) {
+ handlers = uacpi_node_get_address_space_handlers(parent);
+ if (handlers != UACPI_NULL) {
+ handler = find_handler(handlers, region->space);
+
+ if (handler != UACPI_NULL) {
+ region_install_handler(node, handler);
+ ret = UACPI_STATUS_OK;
+ break;
+ }
+ }
+
+ parent = parent->parent;
+ }
+
+ if (ret != UACPI_STATUS_OK)
+ goto out;
+ if (!space_needs_reg(region->space))
+ goto out;
+ if (uacpi_get_current_init_level() < UACPI_INIT_LEVEL_NAMESPACE_LOADED)
+ goto out;
+
+ if (region_run_reg(node, ACPI_REG_CONNECT) != UACPI_STATUS_NOT_FOUND)
+ region->state_flags |= UACPI_OP_REGION_STATE_REG_EXECUTED;
+
+out:
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+}
+
+uacpi_bool uacpi_is_buffer_access_address_space(uacpi_address_space space)
+{
+ switch (space) {
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ case UACPI_ADDRESS_SPACE_IPMI:
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ case UACPI_ADDRESS_SPACE_PRM:
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ return UACPI_TRUE;
+ default:
+ return UACPI_FALSE;
+ }
+}
+
+static uacpi_bool space_needs_bounds_checking(uacpi_address_space space)
+{
+ return !uacpi_is_buffer_access_address_space(space) &&
+ space != UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO;
+}
+
+uacpi_status uacpi_dispatch_opregion_io(
+ uacpi_field_unit *field, uacpi_u32 offset, uacpi_region_op op,
+ union uacpi_opregion_io_data data
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ uacpi_operation_region *region;
+ uacpi_address_space_handler *handler;
+ uacpi_address_space space;
+ uacpi_u64 abs_offset, offset_end = offset;
+ uacpi_bool is_oob = UACPI_FALSE;
+ uacpi_region_op orig_op = op;
+
+ union {
+ uacpi_region_rw_data rw;
+ uacpi_region_pcc_send_data pcc;
+ uacpi_region_gpio_rw_data gpio;
+ uacpi_region_ipmi_rw_data ipmi;
+ uacpi_region_ffixedhw_rw_data ffixedhw;
+ uacpi_region_prm_rw_data prm;
+ uacpi_region_serial_rw_data serial;
+ } handler_data;
+
+ ret = upgrade_to_opregion_lock();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_opregion_attach(field->region);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_trace_region_error(
+ field->region, "unable to attach", ret
+ );
+ goto out;
+ }
+
+ obj = uacpi_namespace_node_get_object_typed(
+ field->region, UACPI_OBJECT_OPERATION_REGION_BIT
+ );
+ if (uacpi_unlikely(obj == UACPI_NULL)) {
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ region = obj->op_region;
+ space = region->space;
+ handler = region->handler;
+
+ abs_offset = region->offset + offset;
+ offset_end += field->access_width_bytes;
+
+ if (uacpi_likely(space_needs_bounds_checking(region->space)))
+ is_oob = region->length < offset_end || abs_offset < offset;
+ if (uacpi_unlikely(is_oob)) {
+ const uacpi_char *path;
+
+ path = uacpi_namespace_node_generate_absolute_path(field->region);
+ uacpi_error(
+ "out-of-bounds access to opregion %s[0x%"UACPI_PRIX64"->"
+ "0x%"UACPI_PRIX64"] at 0x%"UACPI_PRIX64" (idx=%u, width=%d)\n",
+ path, UACPI_FMT64(region->offset),
+ UACPI_FMT64(region->offset + region->length),
+ UACPI_FMT64(abs_offset), offset, field->access_width_bytes
+ );
+ uacpi_free_dynamic_string(path);
+ ret = UACPI_STATUS_AML_OUT_OF_BOUNDS_INDEX;
+ goto out;
+ }
+
+ handler_data.rw.region_context = region->user_context;
+ handler_data.rw.handler_context = handler->user_context;
+
+ switch (region->space) {
+ case UACPI_ADDRESS_SPACE_PCC: {
+ uacpi_u8 *cursor;
+
+ cursor = region->internal_buffer + offset;
+
+ /*
+ * Reads from PCC just return the current contents of the internal
+ * buffer.
+ */
+ if (op == UACPI_REGION_OP_READ) {
+ uacpi_memcpy_zerout(
+ data.integer, cursor, sizeof(*data.integer),
+ field->access_width_bytes
+ );
+ goto io_done;
+ }
+
+ uacpi_memcpy(cursor, data.integer, field->access_width_bytes);
+
+ /*
+ * Dispatch a PCC send command if this was a write to the command field
+ *
+ * ACPI 6.5: 14.3. Extended PCC Subspace Shared Memory Region
+ */
+ if (offset >= 12 && offset < 16) {
+ uacpi_memzero(&handler_data.pcc.buffer, sizeof(handler_data.pcc.buffer));
+ handler_data.pcc.buffer.bytes = region->internal_buffer;
+ handler_data.pcc.buffer.length = region->length;
+
+ op = UACPI_REGION_OP_PCC_SEND;
+ break;
+ }
+
+ // No dispatch needed, IO is done
+ goto io_done;
+ }
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ handler_data.gpio.pin_offset = field->pin_offset;
+ handler_data.gpio.num_pins = field->bit_length;
+ handler_data.gpio.value = *data.integer;
+
+ ret = uacpi_object_get_string_or_buffer(
+ field->connection, &handler_data.gpio.connection
+ );
+ if (uacpi_unlikely_error(ret))
+ goto io_done;
+
+ op = op == UACPI_REGION_OP_READ ?
+ UACPI_REGION_OP_GPIO_READ : UACPI_REGION_OP_GPIO_WRITE;
+ break;
+ case UACPI_ADDRESS_SPACE_IPMI:
+ handler_data.ipmi.in_out_message = data.buffer;
+ handler_data.ipmi.command = abs_offset;
+ op = UACPI_REGION_OP_IPMI_COMMAND;
+ break;
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ handler_data.ffixedhw.in_out_message = data.buffer;
+ handler_data.ffixedhw.command = abs_offset;
+ op = UACPI_REGION_OP_FFIXEDHW_COMMAND;
+ break;
+ case UACPI_ADDRESS_SPACE_PRM:
+ handler_data.prm.in_out_message = data.buffer;
+ op = UACPI_REGION_OP_PRM_COMMAND;
+ break;
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ ret = uacpi_object_get_string_or_buffer(
+ field->connection, &handler_data.serial.connection
+ );
+ if (uacpi_unlikely_error(ret))
+ goto io_done;
+
+ handler_data.serial.command = abs_offset;
+ handler_data.serial.in_out_buffer = data.buffer;
+ handler_data.serial.access_attribute = field->attributes;
+
+ switch (field->attributes) {
+ case UACPI_ACCESS_ATTRIBUTE_BYTES:
+ case UACPI_ACCESS_ATTRIBUTE_RAW_BYTES:
+ case UACPI_ACCESS_ATTRIBUTE_RAW_PROCESS_BYTES:
+ handler_data.serial.access_length = field->access_length;
+ break;
+ default:
+ handler_data.serial.access_length = 0;
+ }
+
+ op = op == UACPI_REGION_OP_READ ?
+ UACPI_REGION_OP_SERIAL_READ : UACPI_REGION_OP_SERIAL_WRITE;
+ break;
+ default:
+ handler_data.rw.byte_width = field->access_width_bytes;
+ handler_data.rw.offset = abs_offset;
+ handler_data.rw.value = *data.integer;
+ break;
+ }
+
+ uacpi_object_ref(obj);
+ uacpi_namespace_write_unlock();
+
+ ret = handler->callback(op, &handler_data);
+
+ uacpi_namespace_write_lock();
+ uacpi_object_unref(obj);
+
+io_done:
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_trace_region_error(field->region, "unable to perform IO", ret);
+ goto out;
+ }
+
+ if (orig_op == UACPI_REGION_OP_READ) {
+ switch (region->space) {
+ case UACPI_ADDRESS_SPACE_PCC:
+ case UACPI_ADDRESS_SPACE_IPMI:
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ case UACPI_ADDRESS_SPACE_PRM:
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ break;
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ *data.integer = handler_data.gpio.value;
+ break;
+ default:
+ *data.integer = handler_data.rw.value;
+ break;
+ }
+ }
+
+ trace_region_io(field, space, abs_offset, orig_op, data);
+
+out:
+ uacpi_recursive_lock_release(&g_opregion_lock);
+ return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/osi.c b/sys/dev/acpi/uacpi/osi.c
new file mode 100644
index 0000000..0940261
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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
diff --git a/sys/dev/acpi/uacpi/registers.c b/sys/dev/acpi/uacpi/registers.c
new file mode 100644
index 0000000..a52ce97
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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 {
+ struct acpi_gas temp_gas = { 0 };
+
+ if (idx != 0) {
+ mapping->states[idx] = REGISTER_MAPPING_STATE_NOT_NEEDED;
+ return ret;
+ }
+
+ temp_gas.address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO;
+ temp_gas.address = *(uacpi_u32*)spec->accessors[0];
+ temp_gas.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
diff --git a/sys/dev/acpi/uacpi/resources.c b/sys/dev/acpi/uacpi/resources.c
new file mode 100644
index 0000000..a9bcb82
--- /dev/null
+++ b/sys/dev/acpi/uacpi/resources.c
@@ -0,0 +1,2569 @@
+#include <uacpi/types.h>
+#include <uacpi/acpi.h>
+#include <uacpi/internal/resources.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/uacpi.h>
+
+#ifndef UACPI_BAREBONES_MODE
+
+#define LARGE_RESOURCE_BASE (ACPI_RESOURCE_END_TAG + 1)
+#define L(x) (x + LARGE_RESOURCE_BASE)
+
+/*
+ * Map raw AML resource types to the internal enum, this also takes care of type
+ * sanitization by returning UACPI_AML_RESOURCE_INVALID for any unknown type.
+ */
+static const uacpi_u8 aml_resource_to_type[256] = {
+ // Small items
+ [ACPI_RESOURCE_IRQ] = UACPI_AML_RESOURCE_IRQ,
+ [ACPI_RESOURCE_DMA] = UACPI_AML_RESOURCE_DMA,
+ [ACPI_RESOURCE_START_DEPENDENT] = UACPI_AML_RESOURCE_START_DEPENDENT,
+ [ACPI_RESOURCE_END_DEPENDENT] = UACPI_AML_RESOURCE_END_DEPENDENT,
+ [ACPI_RESOURCE_IO] = UACPI_AML_RESOURCE_IO,
+ [ACPI_RESOURCE_FIXED_IO] = UACPI_AML_RESOURCE_FIXED_IO,
+ [ACPI_RESOURCE_FIXED_DMA] = UACPI_AML_RESOURCE_FIXED_DMA,
+ [ACPI_RESOURCE_VENDOR_TYPE0] = UACPI_AML_RESOURCE_VENDOR_TYPE0,
+ [ACPI_RESOURCE_END_TAG] = UACPI_AML_RESOURCE_END_TAG,
+
+ // Large items
+ [L(ACPI_RESOURCE_MEMORY24)] = UACPI_AML_RESOURCE_MEMORY24,
+ [L(ACPI_RESOURCE_GENERIC_REGISTER)] = UACPI_AML_RESOURCE_GENERIC_REGISTER,
+ [L(ACPI_RESOURCE_VENDOR_TYPE1)] = UACPI_AML_RESOURCE_VENDOR_TYPE1,
+ [L(ACPI_RESOURCE_MEMORY32)] = UACPI_AML_RESOURCE_MEMORY32,
+ [L(ACPI_RESOURCE_FIXED_MEMORY32)] = UACPI_AML_RESOURCE_FIXED_MEMORY32,
+ [L(ACPI_RESOURCE_ADDRESS32)] = UACPI_AML_RESOURCE_ADDRESS32,
+ [L(ACPI_RESOURCE_ADDRESS16)] = UACPI_AML_RESOURCE_ADDRESS16,
+ [L(ACPI_RESOURCE_EXTENDED_IRQ)] = UACPI_AML_RESOURCE_EXTENDED_IRQ,
+ [L(ACPI_RESOURCE_ADDRESS64_EXTENDED)] = UACPI_AML_RESOURCE_ADDRESS64_EXTENDED,
+ [L(ACPI_RESOURCE_ADDRESS64)] = UACPI_AML_RESOURCE_ADDRESS64,
+ [L(ACPI_RESOURCE_GPIO_CONNECTION)] = UACPI_AML_RESOURCE_GPIO_CONNECTION,
+ [L(ACPI_RESOURCE_PIN_FUNCTION)] = UACPI_AML_RESOURCE_PIN_FUNCTION,
+ [L(ACPI_RESOURCE_SERIAL_CONNECTION)] = UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ [L(ACPI_RESOURCE_PIN_CONFIGURATION)] = UACPI_AML_RESOURCE_PIN_CONFIGURATION,
+ [L(ACPI_RESOURCE_PIN_GROUP)] = UACPI_AML_RESOURCE_PIN_GROUP,
+ [L(ACPI_RESOURCE_PIN_GROUP_FUNCTION)] = UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION,
+ [L(ACPI_RESOURCE_PIN_GROUP_CONFIGURATION)] = UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION,
+ [L(ACPI_RESOURCE_CLOCK_INPUT)] = UACPI_AML_RESOURCE_CLOCK_INPUT,
+};
+
+static const uacpi_u8 type_to_aml_resource[] = {
+ [UACPI_AML_RESOURCE_IRQ] = ACPI_RESOURCE_IRQ,
+ [UACPI_AML_RESOURCE_DMA] = ACPI_RESOURCE_DMA,
+ [UACPI_AML_RESOURCE_START_DEPENDENT] = ACPI_RESOURCE_START_DEPENDENT,
+ [UACPI_AML_RESOURCE_END_DEPENDENT] = ACPI_RESOURCE_END_DEPENDENT,
+ [UACPI_AML_RESOURCE_IO] = ACPI_RESOURCE_IO,
+ [UACPI_AML_RESOURCE_FIXED_IO] = ACPI_RESOURCE_FIXED_IO,
+ [UACPI_AML_RESOURCE_FIXED_DMA] = ACPI_RESOURCE_FIXED_DMA,
+ [UACPI_AML_RESOURCE_VENDOR_TYPE0] = ACPI_RESOURCE_VENDOR_TYPE0,
+ [UACPI_AML_RESOURCE_END_TAG] = ACPI_RESOURCE_END_TAG,
+
+ // Large items
+ [UACPI_AML_RESOURCE_MEMORY24] = ACPI_RESOURCE_MEMORY24,
+ [UACPI_AML_RESOURCE_GENERIC_REGISTER] = ACPI_RESOURCE_GENERIC_REGISTER,
+ [UACPI_AML_RESOURCE_VENDOR_TYPE1] = ACPI_RESOURCE_VENDOR_TYPE1,
+ [UACPI_AML_RESOURCE_MEMORY32] = ACPI_RESOURCE_MEMORY32,
+ [UACPI_AML_RESOURCE_FIXED_MEMORY32] = ACPI_RESOURCE_FIXED_MEMORY32,
+ [UACPI_AML_RESOURCE_ADDRESS32] = ACPI_RESOURCE_ADDRESS32,
+ [UACPI_AML_RESOURCE_ADDRESS16] = ACPI_RESOURCE_ADDRESS16,
+ [UACPI_AML_RESOURCE_EXTENDED_IRQ] = ACPI_RESOURCE_EXTENDED_IRQ,
+ [UACPI_AML_RESOURCE_ADDRESS64_EXTENDED] = ACPI_RESOURCE_ADDRESS64_EXTENDED,
+ [UACPI_AML_RESOURCE_ADDRESS64] = ACPI_RESOURCE_ADDRESS64,
+ [UACPI_AML_RESOURCE_GPIO_CONNECTION] = ACPI_RESOURCE_GPIO_CONNECTION,
+ [UACPI_AML_RESOURCE_PIN_FUNCTION] = ACPI_RESOURCE_PIN_FUNCTION,
+ [UACPI_AML_RESOURCE_SERIAL_CONNECTION] = ACPI_RESOURCE_SERIAL_CONNECTION,
+ [UACPI_AML_RESOURCE_PIN_CONFIGURATION] = ACPI_RESOURCE_PIN_CONFIGURATION,
+ [UACPI_AML_RESOURCE_PIN_GROUP] = ACPI_RESOURCE_PIN_GROUP,
+ [UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION] = ACPI_RESOURCE_PIN_GROUP_FUNCTION,
+ [UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION] = ACPI_RESOURCE_PIN_GROUP_CONFIGURATION,
+ [UACPI_AML_RESOURCE_CLOCK_INPUT] = ACPI_RESOURCE_CLOCK_INPUT,
+};
+
+static const uacpi_u8 native_resource_to_type[UACPI_RESOURCE_TYPE_MAX + 1] = {
+ [UACPI_RESOURCE_TYPE_IRQ] = UACPI_AML_RESOURCE_IRQ,
+ [UACPI_RESOURCE_TYPE_EXTENDED_IRQ] = UACPI_AML_RESOURCE_EXTENDED_IRQ,
+ [UACPI_RESOURCE_TYPE_DMA] = UACPI_AML_RESOURCE_DMA,
+ [UACPI_RESOURCE_TYPE_FIXED_DMA] = UACPI_AML_RESOURCE_FIXED_DMA,
+ [UACPI_RESOURCE_TYPE_IO] = UACPI_AML_RESOURCE_IO,
+ [UACPI_RESOURCE_TYPE_FIXED_IO] = UACPI_AML_RESOURCE_FIXED_IO,
+ [UACPI_RESOURCE_TYPE_ADDRESS16] = UACPI_AML_RESOURCE_ADDRESS16,
+ [UACPI_RESOURCE_TYPE_ADDRESS32] = UACPI_AML_RESOURCE_ADDRESS32,
+ [UACPI_RESOURCE_TYPE_ADDRESS64] = UACPI_AML_RESOURCE_ADDRESS64,
+ [UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED] = UACPI_AML_RESOURCE_ADDRESS64_EXTENDED,
+ [UACPI_RESOURCE_TYPE_MEMORY24] = UACPI_AML_RESOURCE_MEMORY24,
+ [UACPI_RESOURCE_TYPE_MEMORY32] = UACPI_AML_RESOURCE_MEMORY32,
+ [UACPI_RESOURCE_TYPE_FIXED_MEMORY32] = UACPI_AML_RESOURCE_FIXED_MEMORY32,
+ [UACPI_RESOURCE_TYPE_START_DEPENDENT] = UACPI_AML_RESOURCE_START_DEPENDENT,
+ [UACPI_RESOURCE_TYPE_END_DEPENDENT] = UACPI_AML_RESOURCE_END_DEPENDENT,
+ [UACPI_RESOURCE_TYPE_VENDOR_SMALL] = UACPI_AML_RESOURCE_VENDOR_TYPE0,
+ [UACPI_RESOURCE_TYPE_VENDOR_LARGE] = UACPI_AML_RESOURCE_VENDOR_TYPE1,
+ [UACPI_RESOURCE_TYPE_GENERIC_REGISTER] = UACPI_AML_RESOURCE_GENERIC_REGISTER,
+ [UACPI_RESOURCE_TYPE_GPIO_CONNECTION] = UACPI_AML_RESOURCE_GPIO_CONNECTION,
+ [UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION] = UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ [UACPI_RESOURCE_TYPE_SERIAL_SPI_CONNECTION] = UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ [UACPI_RESOURCE_TYPE_SERIAL_UART_CONNECTION] = UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ [UACPI_RESOURCE_TYPE_SERIAL_CSI2_CONNECTION] = UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ [UACPI_RESOURCE_TYPE_PIN_FUNCTION] = UACPI_AML_RESOURCE_PIN_FUNCTION,
+ [UACPI_RESOURCE_TYPE_PIN_CONFIGURATION] = UACPI_AML_RESOURCE_PIN_CONFIGURATION,
+ [UACPI_RESOURCE_TYPE_PIN_GROUP] = UACPI_AML_RESOURCE_PIN_GROUP,
+ [UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION] = UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION,
+ [UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION] = UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION,
+ [UACPI_RESOURCE_TYPE_CLOCK_INPUT] = UACPI_AML_RESOURCE_CLOCK_INPUT,
+ [UACPI_RESOURCE_TYPE_END_TAG] = UACPI_AML_RESOURCE_END_TAG,
+};
+
+#define SMALL_ITEM_HEADER_SIZE sizeof(struct acpi_small_item)
+#define LARGE_ITEM_HEADER_SIZE sizeof(struct acpi_large_item)
+
+static const uacpi_u8 aml_resource_kind_to_header_size[2] = {
+ [UACPI_AML_RESOURCE_KIND_SMALL] = SMALL_ITEM_HEADER_SIZE,
+ [UACPI_AML_RESOURCE_KIND_LARGE] = LARGE_ITEM_HEADER_SIZE,
+};
+
+static uacpi_size aml_size_with_header(const struct uacpi_resource_spec *spec)
+{
+ return spec->aml_size +
+ aml_resource_kind_to_header_size[spec->resource_kind];
+}
+
+static uacpi_size extra_size_for_native_irq_or_dma(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ uacpi_u16 mask;
+ uacpi_u8 i, total_bits, num_bits = 0;
+
+ UACPI_UNUSED(size);
+
+ if (spec->type == UACPI_AML_RESOURCE_IRQ) {
+ struct acpi_resource_irq *irq = data;
+ mask = irq->irq_mask;
+ total_bits = 16;
+ } else {
+ struct acpi_resource_dma *dma = data;
+ mask = dma->channel_mask;
+ total_bits = 8;
+ }
+
+ for (i = 0; i < total_bits; ++i)
+ num_bits += !!(mask & (1 << i));
+
+ return num_bits;
+}
+
+static uacpi_size size_for_aml_irq(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_resource_irq *irq = &resource->irq;
+ uacpi_size size;
+
+ size = aml_size_with_header(spec);
+
+ switch (irq->length_kind) {
+ case UACPI_RESOURCE_LENGTH_KIND_FULL:
+ goto out_full;
+ case UACPI_RESOURCE_LENGTH_KIND_ONE_LESS:
+ case UACPI_RESOURCE_LENGTH_KIND_DONT_CARE:
+ if (irq->triggering != UACPI_TRIGGERING_EDGE)
+ goto out_full;
+ if (irq->polarity != UACPI_POLARITY_ACTIVE_HIGH)
+ goto out_full;
+ if (irq->sharing != UACPI_EXCLUSIVE)
+ goto out_full;
+
+ return size - 1;
+ }
+
+out_full:
+ if (uacpi_unlikely(irq->length_kind ==
+ UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)) {
+ uacpi_warn("requested IRQ resource length is "
+ "not compatible with specified flags, corrected\n");
+ }
+
+ return size;
+}
+
+static uacpi_size size_for_aml_start_dependent(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_resource_start_dependent *start_dep = &resource->start_dependent;
+ uacpi_size size;
+
+ size = aml_size_with_header(spec);
+ switch (start_dep->length_kind) {
+ case UACPI_RESOURCE_LENGTH_KIND_FULL:
+ goto out_full;
+ case UACPI_RESOURCE_LENGTH_KIND_ONE_LESS:
+ case UACPI_RESOURCE_LENGTH_KIND_DONT_CARE:
+ if (start_dep->compatibility != UACPI_ACCEPTABLE)
+ goto out_full;
+ if (start_dep->performance != UACPI_ACCEPTABLE)
+ goto out_full;
+
+ return size - 1;
+ }
+
+out_full:
+ if (uacpi_unlikely(start_dep->length_kind ==
+ UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)) {
+ uacpi_warn("requested StartDependentFn resource length is "
+ "not compatible with specified flags, corrected\n");
+ }
+
+ return size;
+}
+
+static uacpi_size extra_size_for_native_vendor(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ UACPI_UNUSED(spec);
+ UACPI_UNUSED(data);
+ return size;
+}
+
+static uacpi_size size_for_aml_vendor(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_size size = resource->vendor.length;
+
+ UACPI_UNUSED(spec);
+
+ if (size > 7 || resource->type == UACPI_RESOURCE_TYPE_VENDOR_LARGE) {
+ size += aml_resource_kind_to_header_size[
+ UACPI_AML_RESOURCE_KIND_LARGE
+ ];
+
+ if (uacpi_unlikely(resource->type != UACPI_RESOURCE_TYPE_VENDOR_LARGE)) {
+ uacpi_warn("vendor data too large for small descriptor (%zu), "
+ "correcting to large\n", size);
+ resource->type = UACPI_RESOURCE_TYPE_VENDOR_LARGE;
+ }
+ } else {
+ size += aml_resource_kind_to_header_size[
+ UACPI_AML_RESOURCE_KIND_SMALL
+ ];
+ }
+
+ return size;
+}
+
+static uacpi_size extra_size_for_resource_source(
+ uacpi_size base_size, uacpi_size reported_size
+)
+{
+ uacpi_size string_length;
+
+ if (reported_size <= base_size)
+ return 0;
+
+ /*
+ * The remainder of the descriptor minus the resource index field
+ */
+ string_length = (reported_size - base_size) - 1;
+ return UACPI_ALIGN_UP(string_length, sizeof(void*), uacpi_size);
+}
+
+static uacpi_size size_for_aml_resource_source(
+ uacpi_resource_source *source, uacpi_bool with_index
+)
+{
+ uacpi_size length = source->length;
+
+ if (uacpi_unlikely(length && !source->index_present)) {
+ uacpi_warn("resource declares no source index with non-empty "
+ "string (%zu bytes), corrected\n", length);
+ source->index_present = UACPI_TRUE;
+ }
+
+ // If index is included in the dynamic resource source, add it to the length
+ if (with_index)
+ length += source->index_present;
+
+ return length;
+}
+
+static uacpi_size extra_size_for_native_address_or_clock_input(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ UACPI_UNUSED(data);
+ return extra_size_for_resource_source(spec->aml_size, size);
+}
+
+static uacpi_size size_for_aml_address_or_clock_input(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_resource_source *source;
+ bool has_index = UACPI_TRUE;
+
+ switch (resource->type) {
+ case UACPI_RESOURCE_TYPE_ADDRESS16:
+ source = &resource->address16.source;
+ break;
+ case UACPI_RESOURCE_TYPE_ADDRESS32:
+ source = &resource->address32.source;
+ break;
+ case UACPI_RESOURCE_TYPE_ADDRESS64:
+ source = &resource->address64.source;
+ break;
+ case UACPI_RESOURCE_TYPE_CLOCK_INPUT:
+ source = &resource->clock_input.source;
+ has_index = UACPI_FALSE;
+ break;
+ default:
+ return 0;
+ }
+
+ return aml_size_with_header(spec) +
+ size_for_aml_resource_source(source, has_index);
+}
+
+static uacpi_size extra_size_for_extended_irq(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ struct acpi_resource_extended_irq *irq = data;
+ uacpi_size extra_size = 0;
+
+ extra_size += irq->num_irqs * sizeof(uacpi_u32);
+ extra_size += extra_size_for_resource_source(
+ spec->aml_size, size - extra_size
+ );
+
+ return extra_size;
+}
+
+static uacpi_size size_for_aml_extended_irq(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_resource_extended_irq *irq = &resource->extended_irq;
+ uacpi_size size;
+
+ size = aml_size_with_header(spec);
+ size += irq->num_irqs * 4;
+ size += size_for_aml_resource_source(&irq->source, UACPI_TRUE);
+
+ return size;
+}
+
+static uacpi_size extra_size_for_native_gpio_or_pins(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ uacpi_size pin_table_offset;
+
+ /*
+ * These resources pretend to have variable layout by declaring "offset"
+ * fields, but the layout is hardcoded and mandated by the spec to be
+ * very specific. We can use the offset numbers here to calculate the final
+ * length.
+ *
+ * For example, the layout of GPIO connection _always_ looks as follows:
+ * [0...22] -> fixed data
+ * [23...<source name offset - 1>] -> pin table
+ * [<source name offset>...<vendor data offset - 1>] -> source name
+ * [<vendor data offset>...<data offset + data length>] -> vendor data
+ */
+ switch (spec->type) {
+ case UACPI_AML_RESOURCE_GPIO_CONNECTION: {
+ struct acpi_resource_gpio_connection *gpio = data;
+ pin_table_offset = gpio->pin_table_offset;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_FUNCTION: {
+ struct acpi_resource_pin_function *pin = data;
+ pin_table_offset = pin->pin_table_offset;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_CONFIGURATION: {
+ struct acpi_resource_pin_configuration *config = data;
+ pin_table_offset = config->pin_table_offset;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_GROUP: {
+ struct acpi_resource_pin_group *group = data;
+ pin_table_offset = group->pin_table_offset;
+ break;
+ }
+
+ default:
+ return 0;
+ }
+
+ /*
+ * The size we get passed here does not include the header size because
+ * that's how resources are encoded. Subtract it here so that we get the
+ * correct final length.
+ */
+ return size - (pin_table_offset - LARGE_ITEM_HEADER_SIZE);
+}
+
+static uacpi_size size_for_aml_gpio_or_pins(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_size source_length, vendor_length, pin_table_length, size;
+
+ size = aml_size_with_header(spec);
+ switch (spec->type) {
+ case UACPI_AML_RESOURCE_GPIO_CONNECTION: {
+ uacpi_resource_gpio_connection *res = &resource->gpio_connection;
+ source_length = res->source.length;
+ pin_table_length = res->pin_table_length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_FUNCTION: {
+ uacpi_resource_pin_function *res = &resource->pin_function;
+ source_length = res->source.length;
+ pin_table_length = res->pin_table_length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_CONFIGURATION: {
+ uacpi_resource_pin_configuration *res = &resource->pin_configuration;
+ source_length = res->source.length;
+ pin_table_length = res->pin_table_length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_GROUP: {
+ uacpi_resource_pin_group *res = &resource->pin_group;
+ source_length = res->label.length;
+ pin_table_length = res->pin_table_length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ default:
+ return 0;
+ }
+
+ size += source_length;
+ size += pin_table_length * 2;
+ size += vendor_length;
+
+ return size;
+}
+
+static uacpi_size extra_size_for_native_pin_group(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ uacpi_size source_offset;
+
+ switch (spec->type) {
+ case UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION: {
+ struct acpi_resource_pin_group_function *func = data;
+ source_offset = func->source_offset;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION: {
+ struct acpi_resource_pin_group_configuration *config = data;
+ source_offset = config->source_offset;
+ break;
+ }
+
+ default:
+ return 0;
+ }
+
+ // Same logic as extra_size_for_native_gpio_or_pins
+ return size - (source_offset - LARGE_ITEM_HEADER_SIZE);
+}
+
+static uacpi_size size_for_aml_pin_group(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_size source_length, label_length, vendor_length, size;
+
+ size = aml_size_with_header(spec);
+ switch (spec->type) {
+ case UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION: {
+ uacpi_resource_pin_group_function *res = &resource->pin_group_function;
+ source_length = res->source.length;
+ label_length = res->label.length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ case UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION: {
+ uacpi_resource_pin_group_configuration *res;
+ res = &resource->pin_group_configuration;
+ source_length = res->source.length;
+ label_length = res->label.length;
+ vendor_length = res->vendor_data_length;
+ break;
+ }
+
+ default:
+ return 0;
+ }
+
+ size += source_length;
+ size += label_length;
+ size += vendor_length;
+
+ return size;
+}
+
+#define AML_SERIAL_RESOURCE_EXTRA_SIZE(type) \
+ (sizeof(struct acpi_resource_serial_##type) \
+ - sizeof(struct acpi_resource_serial))
+
+#define NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(type) \
+ (sizeof(uacpi_resource_##type##_connection) \
+ - sizeof(uacpi_resource_serial_bus_common))
+
+static const uacpi_u8 aml_serial_resource_to_extra_aml_size
+[ACPI_SERIAL_TYPE_MAX + 1] = {
+ [ACPI_SERIAL_TYPE_I2C] = AML_SERIAL_RESOURCE_EXTRA_SIZE(i2c),
+ [ACPI_SERIAL_TYPE_SPI] = AML_SERIAL_RESOURCE_EXTRA_SIZE(spi),
+ [ACPI_SERIAL_TYPE_UART] = AML_SERIAL_RESOURCE_EXTRA_SIZE(uart),
+ [ACPI_SERIAL_TYPE_CSI2] = AML_SERIAL_RESOURCE_EXTRA_SIZE(csi2),
+};
+
+static const uacpi_u8 aml_serial_resource_to_extra_native_size
+[ACPI_SERIAL_TYPE_MAX + 1] = {
+ [ACPI_SERIAL_TYPE_I2C] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(i2c),
+ [ACPI_SERIAL_TYPE_SPI] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(spi),
+ [ACPI_SERIAL_TYPE_UART] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(uart),
+ [ACPI_SERIAL_TYPE_CSI2] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(csi2),
+};
+
+static uacpi_size extra_size_for_serial_connection(
+ const struct uacpi_resource_spec *spec, void *data, uacpi_size size
+)
+{
+ struct acpi_resource_serial *serial = data;
+ uacpi_size extra_bytes = size;
+
+ extra_bytes -= spec->aml_size;
+ extra_bytes -= aml_serial_resource_to_extra_aml_size[serial->type];
+ extra_bytes += aml_serial_resource_to_extra_native_size[serial->type];
+
+ return extra_bytes;
+}
+
+static uacpi_size aml_size_for_serial_connection(
+ const struct uacpi_resource_spec *spec, uacpi_resource *resource
+)
+{
+ uacpi_size size;
+ uacpi_resource_serial_bus_common *serial_bus = &resource->serial_bus_common;
+
+ size = aml_size_with_header(spec);
+ size += aml_serial_resource_to_extra_aml_size[serial_bus->type];
+ size += serial_bus->vendor_data_length;
+ size += serial_bus->source.length;
+
+ return size;
+}
+
+#define OP(short_code, ...) \
+{ \
+ .code = UACPI_RESOURCE_CONVERT_OPCODE_##short_code, \
+ __VA_ARGS__ \
+}
+
+#define END() OP(END)
+
+#define AML_O(short_aml_name, field) \
+ uacpi_offsetof(struct acpi_resource_##short_aml_name, field)
+
+#define AML_F(short_aml_name, field) \
+ .f1.aml_offset = AML_O(short_aml_name, field)
+
+#define NATIVE_O(short_name, field) \
+ uacpi_offsetof(uacpi_resource_##short_name, field)
+
+#define NATIVE_F(short_native_name, field) \
+ .f2.native_offset = NATIVE_O(short_native_name, field)
+
+#define IMM(value) .f3.imm = value
+#define ARG0(value) .f1.arg0 = (value)
+#define ARG1(value) .f2.arg1 = (value)
+#define ARG2(value) .f3.arg2 = (value)
+
+
+static const struct uacpi_resource_convert_instruction convert_irq_to_native[] = {
+ OP(PACKED_ARRAY_16, AML_F(irq, irq_mask), NATIVE_F(irq, irqs),
+ ARG2(NATIVE_O(irq, num_irqs))),
+ OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(3), IMM(6)),
+ OP(SET_TO_IMM, NATIVE_F(irq, length_kind),
+ IMM(UACPI_RESOURCE_LENGTH_KIND_FULL)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, triggering), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, polarity), IMM(3)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, sharing), IMM(4)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, wake_capability), IMM(5)),
+ END(),
+ OP(SET_TO_IMM, NATIVE_F(irq, length_kind),
+ IMM(UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)),
+ OP(SET_TO_IMM, NATIVE_F(irq, triggering), IMM(UACPI_TRIGGERING_EDGE)),
+ END(),
+};
+
+const struct uacpi_resource_convert_instruction convert_irq_to_aml[] = {
+ OP(PACKED_ARRAY_16, AML_F(irq, irq_mask), NATIVE_F(irq, irqs),
+ ARG2(NATIVE_O(irq, num_irqs))),
+ OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(3), IMM(4)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, triggering), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, polarity), IMM(3)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, sharing), IMM(4)),
+ OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, wake_capability), IMM(5)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_dma[] = {
+ OP(PACKED_ARRAY_8, AML_F(dma, channel_mask), NATIVE_F(dma, channels),
+ ARG2(NATIVE_O(dma, num_channels))),
+ OP(BIT_FIELD_2, AML_F(dma, flags), NATIVE_F(dma, transfer_type), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(dma, flags), NATIVE_F(dma, bus_master_status), IMM(2)),
+ OP(BIT_FIELD_2, AML_F(dma, flags), NATIVE_F(dma, channel_speed), IMM(5)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_start_dependent_to_native[] = {
+ OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(1), IMM(4)),
+ OP(SET_TO_IMM, NATIVE_F(start_dependent, length_kind),
+ IMM(UACPI_RESOURCE_LENGTH_KIND_FULL)),
+ OP(BIT_FIELD_2, AML_F(start_dependent, flags),
+ NATIVE_F(start_dependent, compatibility), IMM(0)),
+ OP(BIT_FIELD_2, AML_F(start_dependent, flags),
+ NATIVE_F(start_dependent, performance), IMM(2)),
+ END(),
+ OP(SET_TO_IMM, NATIVE_F(start_dependent, length_kind),
+ IMM(UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)),
+ OP(SET_TO_IMM, NATIVE_F(start_dependent, compatibility),
+ IMM(UACPI_ACCEPTABLE)),
+ OP(SET_TO_IMM, NATIVE_F(start_dependent, performance),
+ IMM(UACPI_ACCEPTABLE)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_start_dependent_to_aml[] = {
+ OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(1), IMM(1)),
+ OP(BIT_FIELD_2, AML_F(start_dependent, flags),
+ NATIVE_F(start_dependent, compatibility), IMM(0)),
+ OP(BIT_FIELD_2, AML_F(start_dependent, flags),
+ NATIVE_F(start_dependent, performance), IMM(2)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_io[] = {
+ OP(BIT_FIELD_1, AML_F(io, information), NATIVE_F(io, decode_type)),
+ OP(FIELD_16, AML_F(io, minimum), NATIVE_F(io, minimum)),
+ OP(FIELD_16, AML_F(io, maximum), NATIVE_F(io, maximum)),
+ OP(FIELD_8, AML_F(io, alignment), NATIVE_F(io, alignment)),
+ OP(FIELD_8, AML_F(io, length), NATIVE_F(io, length)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_fixed_io[] = {
+ OP(FIELD_16, AML_F(fixed_io, address), NATIVE_F(fixed_io, address)),
+ OP(FIELD_8, AML_F(fixed_io, length), NATIVE_F(fixed_io, length)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_fixed_dma[] = {
+ OP(FIELD_16, AML_F(fixed_dma, request_line),
+ NATIVE_F(fixed_dma, request_line)),
+ OP(FIELD_16, AML_F(fixed_dma, channel), NATIVE_F(fixed_dma, channel)),
+ OP(FIELD_8, AML_F(fixed_dma, transfer_width),
+ NATIVE_F(fixed_dma, transfer_width)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_vendor_type0[] = {
+ OP(LOAD_AML_SIZE_32, NATIVE_F(vendor, length)),
+ OP(FIELD_8, AML_F(vendor_defined_type0, byte_data), NATIVE_F(vendor, data)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_vendor_type1[] = {
+ OP(LOAD_AML_SIZE_32, NATIVE_F(vendor, length)),
+ OP(FIELD_8, AML_F(vendor_defined_type1, byte_data), NATIVE_F(vendor, data)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_memory24[] = {
+ OP(BIT_FIELD_1, AML_F(memory24, information),
+ NATIVE_F(memory24, write_status), IMM(0)),
+ OP(FIELD_16, AML_F(memory24, minimum), NATIVE_F(memory24, minimum), IMM(4)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_memory32[] = {
+ OP(BIT_FIELD_1, AML_F(memory32, information),
+ NATIVE_F(memory32, write_status), IMM(0)),
+ OP(FIELD_32, AML_F(memory32, minimum), NATIVE_F(memory32, minimum), IMM(4)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_fixed_memory32[] = {
+ OP(BIT_FIELD_1, AML_F(fixed_memory32, information),
+ NATIVE_F(fixed_memory32, write_status), IMM(0)),
+ OP(FIELD_32, AML_F(fixed_memory32, address),
+ NATIVE_F(fixed_memory32, address)),
+ OP(FIELD_32, AML_F(fixed_memory32, length),
+ NATIVE_F(fixed_memory32, length)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_generic_register[] = {
+ OP(FIELD_8, AML_F(generic_register, address_space_id),
+ NATIVE_F(generic_register, address_space_id), IMM(4)),
+ OP(FIELD_64, AML_F(generic_register, address),
+ NATIVE_F(generic_register, address)),
+ END(),
+};
+
+#define CONVERT_TYPE_SPECIFIC_FLAGS(addr_type) \
+ OP(LOAD_8_STORE, AML_F(addr_type, common.type), \
+ NATIVE_F(addr_type, common.type)), \
+ OP(SKIP_IF_NOT_EQUALS, ARG0(UACPI_RANGE_MEMORY), IMM(5)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.memory.write_status), IMM(0)), \
+ OP(BIT_FIELD_2, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.memory.caching), IMM(1)), \
+ OP(BIT_FIELD_2, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.memory.range_type), IMM(3)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.memory.translation), IMM(5)), \
+ END(), \
+ OP(SKIP_IF_NOT_EQUALS, ARG0(UACPI_RANGE_IO), IMM(4)), \
+ OP(BIT_FIELD_2, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.io.range_type), IMM(0)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.io.translation_type), IMM(4)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.io.translation), IMM(5)), \
+ END(), \
+ /* Memory type that we don't know, just copy the byte */ \
+ OP(FIELD_8, AML_F(addr_type, common.type_flags), \
+ NATIVE_F(addr_type, common.attribute.type_specific), IMM(0xFF)), \
+ END()
+
+#define CONVERT_GENERAL_ADDRESS_FLAGS(addr_type) \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.flags), \
+ NATIVE_F(addr_type, common.direction), IMM(0)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.flags), \
+ NATIVE_F(addr_type, common.decode_type), IMM(1)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.flags), \
+ NATIVE_F(addr_type, common.fixed_min_address), IMM(2)), \
+ OP(BIT_FIELD_1, \
+ AML_F(addr_type, common.flags), \
+ NATIVE_F(addr_type, common.fixed_max_address), IMM(3)) \
+
+#define DEFINE_ADDRESS_CONVERSION(width) \
+ static const struct uacpi_resource_convert_instruction \
+ convert_address##width[] = { \
+ CONVERT_GENERAL_ADDRESS_FLAGS(address##width), \
+ OP(FIELD_##width, AML_F(address##width, granularity), \
+ NATIVE_F(address##width, granularity), IMM(5)), \
+ OP(RESOURCE_SOURCE, NATIVE_F(address##width, source)), \
+ CONVERT_TYPE_SPECIFIC_FLAGS(address##width), \
+ };
+
+DEFINE_ADDRESS_CONVERSION(16)
+DEFINE_ADDRESS_CONVERSION(32)
+DEFINE_ADDRESS_CONVERSION(64)
+
+static const struct uacpi_resource_convert_instruction
+convert_address64_extended[] = {
+ CONVERT_GENERAL_ADDRESS_FLAGS(address64_extended),
+ OP(FIELD_8, AML_F(address64_extended, revision_id),
+ NATIVE_F(address64_extended, revision_id)),
+ OP(FIELD_64, AML_F(address64_extended, granularity),
+ NATIVE_F(address64_extended, granularity), IMM(6)),
+ CONVERT_TYPE_SPECIFIC_FLAGS(address64_extended),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_extended_irq[] = {
+ OP(BIT_FIELD_1, AML_F(extended_irq, flags),
+ NATIVE_F(extended_irq, direction), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(extended_irq, flags),
+ NATIVE_F(extended_irq, triggering), IMM(1)),
+ OP(BIT_FIELD_1, AML_F(extended_irq, flags),
+ NATIVE_F(extended_irq, polarity), IMM(2)),
+ OP(BIT_FIELD_1, AML_F(extended_irq, flags),
+ NATIVE_F(extended_irq, sharing), IMM(3)),
+ OP(BIT_FIELD_1, AML_F(extended_irq, flags),
+ NATIVE_F(extended_irq, wake_capability), IMM(4)),
+ OP(LOAD_8_STORE, AML_F(extended_irq, num_irqs),
+ NATIVE_F(extended_irq, num_irqs), IMM(4)),
+ OP(RESOURCE_SOURCE, NATIVE_F(extended_irq, source)),
+
+ // Use FIELD_8 here since the accumulator has been multiplied by 4
+ OP(FIELD_8, AML_F(extended_irq, irqs), NATIVE_F(extended_irq, irqs)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_clock_input[] = {
+ OP(FIELD_8, AML_F(clock_input, revision_id),
+ NATIVE_F(clock_input, revision_id)),
+ OP(BIT_FIELD_1, AML_F(clock_input, flags), NATIVE_F(clock_input, frequency),
+ IMM(0)),
+ OP(BIT_FIELD_2, AML_F(clock_input, flags), NATIVE_F(clock_input, scale),
+ IMM(1)),
+ OP(FIELD_16, AML_F(clock_input, divisor), NATIVE_F(clock_input, divisor)),
+ OP(FIELD_32, AML_F(clock_input, numerator), NATIVE_F(clock_input, numerator)),
+ OP(FIELD_8, AML_F(clock_input, source_index), NATIVE_F(clock_input, source.index)),
+ OP(RESOURCE_SOURCE_NO_INDEX, NATIVE_F(clock_input, source)),
+ END(),
+};
+
+#define DECODE_SOURCE_INDEX(short_aml_name) \
+ OP(FIELD_8, AML_F(short_aml_name, source_index), \
+ NATIVE_F(short_aml_name, source.index)) \
+
+#define DECODE_RES_PIN_TBL_AND_VENDOR_DATA( \
+ short_aml_name, res_opcode, offset_field, res_field \
+) \
+ OP(LOAD_PIN_TABLE_LENGTH, AML_F(short_aml_name, offset_field), \
+ NATIVE_F(short_aml_name, pin_table_length)), \
+ OP(RESOURCE_##res_opcode, NATIVE_F(short_aml_name, res_field), \
+ AML_F(short_aml_name, offset_field), \
+ ARG2(AML_O(short_aml_name, vendor_data_offset))), \
+ OP(PIN_TABLE, AML_F(short_aml_name, pin_table_offset), \
+ NATIVE_F(short_aml_name, pin_table_length), \
+ ARG2(NATIVE_O(short_aml_name, pin_table))), \
+ OP(VENDOR_DATA, AML_F(short_aml_name, vendor_data_offset), \
+ NATIVE_F(short_aml_name, vendor_data_length), \
+ ARG2(NATIVE_O(short_aml_name, vendor_data)))
+
+static const struct uacpi_resource_convert_instruction
+convert_gpio_connection[] = {
+ OP(FIELD_8, AML_F(gpio_connection, revision_id),
+ NATIVE_F(gpio_connection, revision_id)),
+ OP(BIT_FIELD_1, AML_F(gpio_connection, general_flags),
+ NATIVE_F(gpio_connection, direction)),
+ OP(FIELD_8, AML_F(gpio_connection, pull_configuration),
+ NATIVE_F(gpio_connection, pull_configuration)),
+ OP(FIELD_16, AML_F(gpio_connection, drive_strength),
+ NATIVE_F(gpio_connection, drive_strength), IMM(2)),
+ DECODE_SOURCE_INDEX(gpio_connection),
+ DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
+ gpio_connection, SOURCE_NO_INDEX, source_offset, source
+ ),
+ OP(LOAD_8_STORE, AML_F(gpio_connection, type), NATIVE_F(gpio_connection, type)),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(UACPI_GPIO_CONNECTION_INTERRUPT), IMM(5)),
+ OP(BIT_FIELD_1, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, intr.triggering), IMM(0)),
+ OP(BIT_FIELD_2, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, intr.polarity), IMM(1)),
+ OP(BIT_FIELD_1, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, intr.sharing), IMM(3)),
+ OP(BIT_FIELD_1, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, intr.wake_capability), IMM(4)),
+ END(),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(UACPI_GPIO_CONNECTION_IO), IMM(3)),
+ OP(BIT_FIELD_2, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, io.restriction), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, io.sharing), IMM(3)),
+ END(),
+ OP(FIELD_16, AML_F(gpio_connection, connection_flags),
+ NATIVE_F(gpio_connection, type_specific), IMM(0xFF)),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_pin_function[] = {
+ OP(FIELD_8, AML_F(pin_function, revision_id),
+ NATIVE_F(pin_function, revision_id)),
+ OP(BIT_FIELD_1, AML_F(pin_function, flags),
+ NATIVE_F(pin_function, sharing), IMM(0)),
+ OP(FIELD_8, AML_F(pin_function, pull_configuration),
+ NATIVE_F(pin_function, pull_configuration)),
+ OP(FIELD_16, AML_F(pin_function, function_number),
+ NATIVE_F(pin_function, function_number)),
+ DECODE_SOURCE_INDEX(pin_function),
+ DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
+ pin_function, SOURCE_NO_INDEX, source_offset, source
+ ),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_pin_configuration[] = {
+ OP(FIELD_8, AML_F(pin_configuration, revision_id),
+ NATIVE_F(pin_configuration, revision_id)),
+ OP(BIT_FIELD_1, AML_F(pin_configuration, flags),
+ NATIVE_F(pin_configuration, sharing), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(pin_configuration, flags),
+ NATIVE_F(pin_configuration, direction), IMM(1)),
+ OP(FIELD_8, AML_F(pin_configuration, type),
+ NATIVE_F(pin_configuration, type)),
+ OP(FIELD_32, AML_F(pin_configuration, value),
+ NATIVE_F(pin_configuration, value)),
+ DECODE_SOURCE_INDEX(pin_configuration),
+ DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
+ pin_configuration, SOURCE_NO_INDEX, source_offset, source
+ ),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction convert_pin_group[] = {
+ OP(FIELD_8, AML_F(pin_group, revision_id),
+ NATIVE_F(pin_group, revision_id)),
+ OP(BIT_FIELD_1, AML_F(pin_group, flags),
+ NATIVE_F(pin_group, direction), IMM(0)),
+ DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
+ pin_group, LABEL, source_lable_offset, label
+ ),
+ END(),
+};
+
+#define DECODE_PIN_GROUP_RES_SOURCES(postfix) \
+ DECODE_SOURCE_INDEX(pin_group_##postfix), \
+ OP(RESOURCE_SOURCE_NO_INDEX, NATIVE_F(pin_group_##postfix, source), \
+ AML_F(pin_group_##postfix, source_offset), \
+ ARG2(AML_O(pin_group_##postfix, source_lable_offset))), \
+ OP(LOAD_16_NATIVE, NATIVE_F(pin_group_##postfix, source.length)), \
+ OP(RESOURCE_LABEL, NATIVE_F(pin_group_##postfix, label), \
+ AML_F(pin_group_##postfix, source_lable_offset), \
+ ARG2(AML_O(pin_group_##postfix, vendor_data_offset))), \
+ OP(VENDOR_DATA, AML_F(pin_group_##postfix, vendor_data_offset), \
+ NATIVE_F(pin_group_##postfix, vendor_data_length), \
+ ARG2(NATIVE_O(pin_group_##postfix, vendor_data)))
+
+static const struct uacpi_resource_convert_instruction
+convert_pin_group_function[] = {
+ OP(FIELD_8, AML_F(pin_group_function, revision_id),
+ NATIVE_F(pin_group_function, revision_id)),
+ OP(BIT_FIELD_1, AML_F(pin_group_function, flags),
+ NATIVE_F(pin_group_function, sharing), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(pin_group_function, flags),
+ NATIVE_F(pin_group_function, direction), IMM(1)),
+ OP(FIELD_16, AML_F(pin_group_function, function),
+ NATIVE_F(pin_group_function, function)),
+ DECODE_PIN_GROUP_RES_SOURCES(function),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_pin_group_configuration[] = {
+ OP(FIELD_8, AML_F(pin_group_configuration, revision_id),
+ NATIVE_F(pin_group_configuration, revision_id)),
+ OP(BIT_FIELD_1, AML_F(pin_group_configuration, flags),
+ NATIVE_F(pin_group_configuration, sharing), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(pin_group_configuration, flags),
+ NATIVE_F(pin_group_configuration, direction), IMM(1)),
+ OP(FIELD_8, AML_F(pin_group_configuration, type),
+ NATIVE_F(pin_group_configuration, type)),
+ OP(FIELD_32, AML_F(pin_group_configuration, value),
+ NATIVE_F(pin_group_configuration, value)),
+ DECODE_PIN_GROUP_RES_SOURCES(configuration),
+ END(),
+};
+
+static const struct uacpi_resource_convert_instruction
+convert_generic_serial_bus[] = {
+ OP(FIELD_8, AML_F(serial, revision_id),
+ NATIVE_F(serial_bus_common, revision_id)),
+ OP(FIELD_8, AML_F(serial, type_specific_revision_id),
+ NATIVE_F(serial_bus_common, type_revision_id)),
+ OP(FIELD_8, AML_F(serial, source_index),
+ NATIVE_F(serial_bus_common, source.index)),
+ OP(FIELD_16, AML_F(serial, type_data_length),
+ NATIVE_F(serial_bus_common, type_data_length)),
+ OP(BIT_FIELD_1, AML_F(serial, flags),
+ NATIVE_F(serial_bus_common, mode), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(serial, flags),
+ NATIVE_F(serial_bus_common, direction), IMM(1)),
+ OP(BIT_FIELD_1, AML_F(serial, flags),
+ NATIVE_F(serial_bus_common, sharing), IMM(2)),
+ OP(SERIAL_TYPE_SPECIFIC, AML_F(serial, type),
+ NATIVE_F(serial_bus_common, type)),
+ OP(RESOURCE_SOURCE_NO_INDEX, NATIVE_F(serial_bus_common, source)),
+ OP(LOAD_8_NATIVE, NATIVE_F(serial_bus_common, type)),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(ACPI_SERIAL_TYPE_I2C), IMM(4)),
+ OP(BIT_FIELD_1, AML_F(serial, type_specific_flags),
+ NATIVE_F(i2c_connection, addressing_mode), IMM(0)),
+ OP(FIELD_32, AML_F(serial_i2c, connection_speed),
+ NATIVE_F(i2c_connection, connection_speed), IMM(0xFF)),
+ OP(FIELD_16, AML_F(serial_i2c, slave_address),
+ NATIVE_F(i2c_connection, slave_address)),
+ END(),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(ACPI_SERIAL_TYPE_SPI), IMM(5)),
+ OP(BIT_FIELD_1, AML_F(serial, type_specific_flags),
+ NATIVE_F(spi_connection, wire_mode), IMM(0)),
+ OP(BIT_FIELD_1, AML_F(serial, type_specific_flags),
+ NATIVE_F(spi_connection, device_polarity), IMM(1)),
+ OP(FIELD_32, AML_F(serial_spi, connection_speed),
+ NATIVE_F(spi_connection, connection_speed), IMM(0xFF)),
+ OP(FIELD_8, AML_F(serial_spi, data_bit_length),
+ NATIVE_F(spi_connection, data_bit_length), IMM(5)),
+ END(),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(ACPI_SERIAL_TYPE_UART), IMM(8)),
+ OP(BIT_FIELD_2, AML_F(serial, type_specific_flags),
+ NATIVE_F(uart_connection, flow_control), IMM(0)),
+ OP(BIT_FIELD_2, AML_F(serial, type_specific_flags),
+ NATIVE_F(uart_connection, stop_bits), IMM(2)),
+ OP(BIT_FIELD_3, AML_F(serial, type_specific_flags),
+ NATIVE_F(uart_connection, data_bits), IMM(4)),
+ OP(BIT_FIELD_1, AML_F(serial, type_specific_flags),
+ NATIVE_F(uart_connection, endianness), IMM(7)),
+ OP(FIELD_32, AML_F(serial_uart, baud_rate),
+ NATIVE_F(uart_connection, baud_rate), IMM(0xFF)),
+ OP(FIELD_16, AML_F(serial_uart, rx_fifo),
+ NATIVE_F(uart_connection, rx_fifo), IMM(2)),
+ OP(FIELD_8, AML_F(serial_uart, parity),
+ NATIVE_F(uart_connection, parity), IMM(2)),
+ END(),
+ OP(SKIP_IF_NOT_EQUALS, ARG0(ACPI_SERIAL_TYPE_CSI2), IMM(3)),
+ OP(BIT_FIELD_2, AML_F(serial, type_specific_flags),
+ NATIVE_F(csi2_connection, phy_type), IMM(0)),
+ OP(BIT_FIELD_6, AML_F(serial, type_specific_flags),
+ NATIVE_F(csi2_connection, local_port), IMM(2)),
+ END(),
+
+ /*
+ * Insert a trap to catch unimplemented types, this should be unreachable
+ * because of validation earlier.
+ */
+ OP(UNREACHABLE),
+};
+
+#define NATIVE_RESOURCE_HEADER_SIZE 8
+
+#define DEFINE_SMALL_AML_RESOURCE(aml_type_enum, native_type_enum, \
+ aml_struct, native_struct, ...) \
+ [aml_type_enum] = { \
+ .type = aml_type_enum, \
+ .native_type = native_type_enum, \
+ .resource_kind = UACPI_AML_RESOURCE_KIND_SMALL, \
+ .aml_size = sizeof(aml_struct) - SMALL_ITEM_HEADER_SIZE, \
+ .native_size = sizeof(native_struct) + NATIVE_RESOURCE_HEADER_SIZE, \
+ __VA_ARGS__ \
+ }
+
+#define DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR( \
+ aml_type_enum, native_type_enum, aml_struct, ... \
+) \
+ [aml_type_enum] = { \
+ .type = aml_type_enum, \
+ .native_type = native_type_enum, \
+ .resource_kind = UACPI_AML_RESOURCE_KIND_SMALL, \
+ .aml_size = sizeof(aml_struct) - SMALL_ITEM_HEADER_SIZE, \
+ .native_size = NATIVE_RESOURCE_HEADER_SIZE, \
+ __VA_ARGS__ \
+ }
+
+#define DEFINE_LARGE_AML_RESOURCE(aml_type_enum, native_type_enum, \
+ aml_struct, native_struct, ...) \
+ [aml_type_enum] = { \
+ .type = aml_type_enum, \
+ .native_type = native_type_enum, \
+ .resource_kind = UACPI_AML_RESOURCE_KIND_LARGE, \
+ .aml_size = sizeof(aml_struct) - LARGE_ITEM_HEADER_SIZE, \
+ .native_size = sizeof(native_struct) + NATIVE_RESOURCE_HEADER_SIZE, \
+ __VA_ARGS__ \
+ }
+
+const struct uacpi_resource_spec aml_resources[UACPI_AML_RESOURCE_MAX + 1] = {
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_IRQ,
+ UACPI_RESOURCE_TYPE_IRQ,
+ struct acpi_resource_irq,
+ uacpi_resource_irq,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS,
+ .extra_size_for_native = extra_size_for_native_irq_or_dma,
+ .size_for_aml = size_for_aml_irq,
+ .to_native = convert_irq_to_native,
+ .to_aml = convert_irq_to_aml,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_DMA,
+ UACPI_RESOURCE_TYPE_DMA,
+ struct acpi_resource_dma,
+ uacpi_resource_dma,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .extra_size_for_native = extra_size_for_native_irq_or_dma,
+ .to_native = convert_dma,
+ .to_aml = convert_dma,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_START_DEPENDENT,
+ UACPI_RESOURCE_TYPE_START_DEPENDENT,
+ struct acpi_resource_start_dependent,
+ uacpi_resource_start_dependent,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS,
+ .size_for_aml = size_for_aml_start_dependent,
+ .to_native = convert_start_dependent_to_native,
+ .to_aml = convert_start_dependent_to_aml,
+ ),
+ DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR(
+ UACPI_AML_RESOURCE_END_DEPENDENT,
+ UACPI_RESOURCE_TYPE_END_DEPENDENT,
+ struct acpi_resource_end_dependent,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_IO,
+ UACPI_RESOURCE_TYPE_IO,
+ struct acpi_resource_io,
+ uacpi_resource_io,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_io,
+ .to_aml = convert_io,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_FIXED_IO,
+ UACPI_RESOURCE_TYPE_FIXED_IO,
+ struct acpi_resource_fixed_io,
+ uacpi_resource_fixed_io,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_fixed_io,
+ .to_aml = convert_fixed_io,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_FIXED_DMA,
+ UACPI_RESOURCE_TYPE_FIXED_DMA,
+ struct acpi_resource_fixed_dma,
+ uacpi_resource_fixed_dma,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_fixed_dma,
+ .to_aml = convert_fixed_dma,
+ ),
+ DEFINE_SMALL_AML_RESOURCE(
+ UACPI_AML_RESOURCE_VENDOR_TYPE0,
+ UACPI_RESOURCE_TYPE_VENDOR_SMALL,
+ struct acpi_resource_vendor_defined_type0,
+ uacpi_resource_vendor,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .size_for_aml = size_for_aml_vendor,
+ .extra_size_for_native = extra_size_for_native_vendor,
+ .to_native = convert_vendor_type0,
+ .to_aml = convert_vendor_type0,
+ ),
+ DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR(
+ UACPI_AML_RESOURCE_END_TAG,
+ UACPI_RESOURCE_TYPE_END_TAG,
+ struct acpi_resource_end_tag,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_MEMORY24,
+ UACPI_RESOURCE_TYPE_MEMORY24,
+ struct acpi_resource_memory24,
+ uacpi_resource_memory24,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_memory24,
+ .to_aml = convert_memory24,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_GENERIC_REGISTER,
+ UACPI_RESOURCE_TYPE_GENERIC_REGISTER,
+ struct acpi_resource_generic_register,
+ uacpi_resource_generic_register,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_generic_register,
+ .to_aml = convert_generic_register,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_VENDOR_TYPE1,
+ UACPI_RESOURCE_TYPE_VENDOR_LARGE,
+ struct acpi_resource_vendor_defined_type1,
+ uacpi_resource_vendor,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_vendor,
+ .size_for_aml = size_for_aml_vendor,
+ .to_native = convert_vendor_type1,
+ .to_aml = convert_vendor_type1,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_MEMORY32,
+ UACPI_RESOURCE_TYPE_MEMORY32,
+ struct acpi_resource_memory32,
+ uacpi_resource_memory32,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_memory32,
+ .to_aml = convert_memory32,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_FIXED_MEMORY32,
+ UACPI_RESOURCE_TYPE_FIXED_MEMORY32,
+ struct acpi_resource_fixed_memory32,
+ uacpi_resource_fixed_memory32,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_fixed_memory32,
+ .to_aml = convert_fixed_memory32,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_ADDRESS32,
+ UACPI_RESOURCE_TYPE_ADDRESS32,
+ struct acpi_resource_address32,
+ uacpi_resource_address32,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_address_or_clock_input,
+ .size_for_aml = size_for_aml_address_or_clock_input,
+ .to_native = convert_address32,
+ .to_aml = convert_address32,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_ADDRESS16,
+ UACPI_RESOURCE_TYPE_ADDRESS16,
+ struct acpi_resource_address16,
+ uacpi_resource_address16,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_address_or_clock_input,
+ .size_for_aml = size_for_aml_address_or_clock_input,
+ .to_native = convert_address16,
+ .to_aml = convert_address16,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_EXTENDED_IRQ,
+ UACPI_RESOURCE_TYPE_EXTENDED_IRQ,
+ struct acpi_resource_extended_irq,
+ uacpi_resource_extended_irq,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_extended_irq,
+ .size_for_aml = size_for_aml_extended_irq,
+ .to_native = convert_extended_irq,
+ .to_aml = convert_extended_irq,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_ADDRESS64,
+ UACPI_RESOURCE_TYPE_ADDRESS64,
+ struct acpi_resource_address64,
+ uacpi_resource_address64,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_address_or_clock_input,
+ .size_for_aml = size_for_aml_address_or_clock_input,
+ .to_native = convert_address64,
+ .to_aml = convert_address64,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_ADDRESS64_EXTENDED,
+ UACPI_RESOURCE_TYPE_ADDRESS64_EXTENDED,
+ struct acpi_resource_address64_extended,
+ uacpi_resource_address64_extended,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_FIXED,
+ .to_native = convert_address64_extended,
+ .to_aml = convert_address64_extended,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_GPIO_CONNECTION,
+ UACPI_RESOURCE_TYPE_GPIO_CONNECTION,
+ struct acpi_resource_gpio_connection,
+ uacpi_resource_gpio_connection,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_gpio_or_pins,
+ .size_for_aml = size_for_aml_gpio_or_pins,
+ .to_aml = convert_gpio_connection,
+ .to_native = convert_gpio_connection,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_PIN_FUNCTION,
+ UACPI_RESOURCE_TYPE_PIN_FUNCTION,
+ struct acpi_resource_pin_function,
+ uacpi_resource_pin_function,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_gpio_or_pins,
+ .size_for_aml = size_for_aml_gpio_or_pins,
+ .to_aml = convert_pin_function,
+ .to_native = convert_pin_function,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_SERIAL_CONNECTION,
+ 0, // the native type here is determined dynamically
+ struct acpi_resource_serial,
+ uacpi_resource_serial_bus_common,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_serial_connection,
+ .size_for_aml = aml_size_for_serial_connection,
+ .to_native = convert_generic_serial_bus,
+ .to_aml = convert_generic_serial_bus,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_PIN_CONFIGURATION,
+ UACPI_RESOURCE_TYPE_PIN_CONFIGURATION,
+ struct acpi_resource_pin_configuration,
+ uacpi_resource_pin_configuration,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_gpio_or_pins,
+ .size_for_aml = size_for_aml_gpio_or_pins,
+ .to_native = convert_pin_configuration,
+ .to_aml = convert_pin_configuration,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_PIN_GROUP,
+ UACPI_RESOURCE_TYPE_PIN_GROUP,
+ struct acpi_resource_pin_group,
+ uacpi_resource_pin_group,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_gpio_or_pins,
+ .size_for_aml = size_for_aml_gpio_or_pins,
+ .to_native = convert_pin_group,
+ .to_aml = convert_pin_group,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION,
+ UACPI_RESOURCE_TYPE_PIN_GROUP_FUNCTION,
+ struct acpi_resource_pin_group_function,
+ uacpi_resource_pin_group_function,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_pin_group,
+ .size_for_aml = size_for_aml_pin_group,
+ .to_native = convert_pin_group_function,
+ .to_aml = convert_pin_group_function,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION,
+ UACPI_RESOURCE_TYPE_PIN_GROUP_CONFIGURATION,
+ struct acpi_resource_pin_group_configuration,
+ uacpi_resource_pin_group_configuration,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_pin_group,
+ .size_for_aml = size_for_aml_pin_group,
+ .to_native = convert_pin_group_configuration,
+ .to_aml = convert_pin_group_configuration,
+ ),
+ DEFINE_LARGE_AML_RESOURCE(
+ UACPI_AML_RESOURCE_CLOCK_INPUT,
+ UACPI_RESOURCE_TYPE_CLOCK_INPUT,
+ struct acpi_resource_clock_input,
+ uacpi_resource_clock_input,
+ .size_kind = UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE,
+ .extra_size_for_native = extra_size_for_native_address_or_clock_input,
+ .size_for_aml = size_for_aml_address_or_clock_input,
+ .to_native = convert_clock_input,
+ .to_aml = convert_clock_input,
+ ),
+};
+
+static enum uacpi_aml_resource get_aml_resource_type(uacpi_u8 raw_byte)
+{
+ if (raw_byte & ACPI_LARGE_ITEM) {
+ return aml_resource_to_type[
+ LARGE_RESOURCE_BASE + (raw_byte & ACPI_LARGE_ITEM_NAME_MASK)
+ ];
+ }
+
+ return aml_resource_to_type[
+ (raw_byte >> ACPI_SMALL_ITEM_NAME_IDX) & ACPI_SMALL_ITEM_NAME_MASK
+ ];
+}
+
+static uacpi_status get_aml_resource_size(
+ uacpi_u8 *data, uacpi_size bytes_left, uacpi_u16 *out_size
+)
+{
+ uacpi_u16 size;
+
+ /*
+ * Resource header is not included in size for both, so we subtract
+ * the header size from bytes_left to validate it.
+ */
+ if (*data & ACPI_LARGE_ITEM) {
+ if (uacpi_unlikely(bytes_left < 3))
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+
+ uacpi_memcpy(&size, data + 1, sizeof(size));
+ bytes_left -= aml_resource_kind_to_header_size[
+ UACPI_AML_RESOURCE_KIND_LARGE
+ ];
+ } else {
+ size = *data & ACPI_SMALL_ITEM_LENGTH_MASK;
+ bytes_left -= aml_resource_kind_to_header_size[
+ UACPI_AML_RESOURCE_KIND_SMALL
+ ];
+ }
+
+ if (uacpi_unlikely(size > bytes_left))
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+
+ *out_size = size;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status validate_aml_serial_type(uacpi_u8 type)
+{
+ if (uacpi_unlikely(type < ACPI_SERIAL_TYPE_I2C ||
+ type > ACPI_SERIAL_TYPE_CSI2)) {
+ uacpi_error("invalid/unsupported serial connection type %d\n", type);
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_for_each_aml_resource(
+ uacpi_data_view buffer, uacpi_aml_resource_iteration_callback cb, void *user
+)
+{
+ uacpi_status ret;
+ uacpi_iteration_decision decision;
+ uacpi_u8 *data;
+ uacpi_size bytes_left;
+ uacpi_u16 resource_size;
+ enum uacpi_aml_resource type;
+ const struct uacpi_resource_spec *spec;
+
+ bytes_left = buffer.length;
+ data = buffer.bytes;
+
+ while (bytes_left) {
+ type = get_aml_resource_type(*data);
+ if (uacpi_unlikely(type == UACPI_AML_RESOURCE_TYPE_INVALID))
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+
+ ret = get_aml_resource_size(data, bytes_left, &resource_size);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ spec = &aml_resources[type];
+ switch (spec->size_kind) {
+ case UACPI_AML_RESOURCE_SIZE_KIND_FIXED:
+ if (resource_size != spec->aml_size)
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+ break;
+ case UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE:
+ if (resource_size < spec->aml_size)
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+ break;
+ case UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS:
+ if (resource_size != spec->aml_size &&
+ resource_size != (spec->aml_size - 1))
+ return UACPI_STATUS_AML_INVALID_RESOURCE;
+ break;
+ default:
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ if (spec->type == UACPI_AML_RESOURCE_SERIAL_CONNECTION) {
+ struct acpi_resource_serial *serial;
+
+ serial = (struct acpi_resource_serial*)data;
+
+ ret = validate_aml_serial_type(serial->type);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ decision = cb(user, data, resource_size, spec);
+ switch (decision) {
+ case UACPI_ITERATION_DECISION_BREAK:
+ return UACPI_STATUS_OK;
+ case UACPI_ITERATION_DECISION_CONTINUE: {
+ uacpi_size total_size = resource_size;
+
+ total_size += aml_resource_kind_to_header_size[spec->resource_kind];
+ data += total_size;
+ bytes_left -= total_size;
+ break;
+ }
+ default:
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ if (type == UACPI_AML_RESOURCE_END_TAG)
+ return UACPI_STATUS_OK;
+ }
+
+ return UACPI_STATUS_NO_RESOURCE_END_TAG;
+}
+
+static uacpi_iteration_decision find_end(
+ void *opaque, uacpi_u8 *data, uacpi_u16 resource_size,
+ const struct uacpi_resource_spec *spec
+)
+{
+ uacpi_u8 **out_ptr = opaque;
+ UACPI_UNUSED(resource_size);
+
+ if (spec->type != UACPI_AML_RESOURCE_END_TAG)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ *out_ptr = data;
+ return UACPI_ITERATION_DECISION_BREAK;
+}
+
+static uacpi_size native_size_for_aml_resource(
+ uacpi_u8 *data, uacpi_u16 size, const struct uacpi_resource_spec *spec
+)
+{
+ uacpi_size final_size = spec->native_size;
+
+ if (spec->extra_size_for_native)
+ final_size += spec->extra_size_for_native(spec, data, size);
+
+ return UACPI_ALIGN_UP(final_size, sizeof(void*), uacpi_size);
+}
+
+uacpi_status uacpi_find_aml_resource_end_tag(
+ uacpi_data_view buffer, uacpi_size *out_offset
+)
+{
+ uacpi_u8 *end_tag_ptr = UACPI_NULL;
+ uacpi_status ret;
+
+ if (buffer.length == 0) {
+ *out_offset = 0;
+ return UACPI_STATUS_OK;
+ }
+
+ /*
+ * This returning UACPI_STATUS_OK guarantees that end_tag_ptr is set to
+ * a valid value because a missing end tag would produce a
+ * UACPI_STATUS_NO_RESOURCE_END_TAG error.
+ */
+ ret = uacpi_for_each_aml_resource(buffer, find_end, &end_tag_ptr);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ *out_offset = end_tag_ptr - buffer.bytes;
+ return UACPI_STATUS_OK;
+}
+
+struct resource_conversion_ctx {
+ union {
+ void *buf;
+ uacpi_u8 *byte_buf;
+ uacpi_size size;
+ };
+ uacpi_status st;
+ uacpi_bool just_one;
+};
+
+static uacpi_iteration_decision conditional_continue(
+ struct resource_conversion_ctx *ctx
+)
+{
+ return ctx->just_one ? UACPI_ITERATION_DECISION_BREAK :
+ UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+// Opcodes that are the same for both AML->native and native->AML
+#define CONVERSION_OPCODES_COMMON(native_buf) \
+ case UACPI_RESOURCE_CONVERT_OPCODE_END: \
+ return conditional_continue(ctx); \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_FIELD_8: \
+ case UACPI_RESOURCE_CONVERT_OPCODE_FIELD_16: \
+ case UACPI_RESOURCE_CONVERT_OPCODE_FIELD_32: \
+ case UACPI_RESOURCE_CONVERT_OPCODE_FIELD_64: { \
+ uacpi_u8 bytes; \
+ \
+ bytes = 1 << (insn->code - UACPI_RESOURCE_CONVERT_OPCODE_FIELD_8); \
+ accumulator = insn->f3.imm == 0xFF ? 0 : accumulator + insn->f3.imm; \
+ \
+ uacpi_memcpy(dst, src, bytes * UACPI_MAX(1, accumulator)); \
+ accumulator = 0; \
+ break; \
+ } \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_AML_SIZE_LESS_THAN: \
+ if (aml_size < insn->f1.arg0) \
+ pc += insn->f3.imm; \
+ break; \
+ case UACPI_RESOURCE_CONVERT_OPCODE_SKIP_IF_NOT_EQUALS: \
+ if (insn->f1.arg0 != accumulator) \
+ pc += insn->f3.imm; \
+ break; \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_SET_TO_IMM: \
+ uacpi_memcpy(dst, &insn->f3.imm, sizeof(insn->f3.imm)); \
+ break; \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_IMM: \
+ accumulator = insn->f3.imm; \
+ break; \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_STORE: \
+ uacpi_memcpy_zerout(&accumulator, src, sizeof(accumulator), 1); \
+ uacpi_memcpy(dst, &accumulator, 1); \
+ \
+ if (insn->f3.imm) \
+ accumulator *= insn->f3.imm; \
+ break; \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_NATIVE: \
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_16_NATIVE: { \
+ uacpi_u8 bytes; \
+ \
+ bytes = \
+ 1 << (insn->code - UACPI_RESOURCE_CONVERT_OPCODE_LOAD_8_NATIVE); \
+ uacpi_memcpy_zerout( \
+ &accumulator, native_buf, sizeof(accumulator), bytes \
+ ); \
+ break; \
+ } \
+ \
+ case UACPI_RESOURCE_CONVERT_OPCODE_UNREACHABLE: \
+ default: \
+ if (insn->code != UACPI_RESOURCE_CONVERT_OPCODE_UNREACHABLE) { \
+ uacpi_error("unhandled resource conversion opcode %d\n", \
+ insn->code); \
+ } else { \
+ uacpi_error("tried to execute unreachable conversion opcode\n"); \
+ } \
+ ctx->st = UACPI_STATUS_INTERNAL_ERROR; \
+ return UACPI_ITERATION_DECISION_BREAK;
+
+#define PTR_AT(ptr, offset) (void*)((uacpi_u8*)(ptr) + (offset))
+
+#define NATIVE_OFFSET(res, offset) \
+ PTR_AT(res, (offset) + (sizeof(uacpi_u32) * 2))
+
+#define NATIVE_FIELD(res, name, field) \
+ NATIVE_OFFSET(res, NATIVE_O(name, field))
+
+#define CHECK_AML_OOB(offset, prefix, what) \
+ if (uacpi_unlikely(offset > ((uacpi_u32)aml_size + header_size))) { \
+ uacpi_error(prefix what " is OOB: %zu > %u\n", \
+ (uacpi_size)offset, (uacpi_u32)aml_size + header_size); \
+ ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE; \
+ return UACPI_ITERATION_DECISION_BREAK; \
+ }
+
+#define CHECK_AML_OFFSET_BASE(offset, what) \
+ if (uacpi_unlikely(offset < base_aml_size_with_header)) { \
+ uacpi_error( \
+ "invalid " what " offset: %zu, expected at least %u\n", \
+ (uacpi_size)offset, base_aml_size_with_header); \
+ ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE; \
+ return UACPI_ITERATION_DECISION_BREAK; \
+ }
+
+#define CHECK_AML_OFFSET(offset, what) \
+ CHECK_AML_OOB(offset, "end of ", what) \
+ CHECK_AML_OFFSET_BASE(offset, what)
+
+static uacpi_resource_type aml_serial_to_native_type(
+ uacpi_u8 type
+)
+{
+ return (type - ACPI_SERIAL_TYPE_I2C) +
+ UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION;
+}
+
+static uacpi_iteration_decision do_aml_resource_to_native(
+ void *opaque, uacpi_u8 *data, uacpi_u16 aml_size,
+ const struct uacpi_resource_spec *spec
+)
+{
+ struct resource_conversion_ctx *ctx = opaque;
+ uacpi_resource *resource = ctx->buf;
+ const struct uacpi_resource_convert_instruction *insns, *insn;
+ uacpi_u8 header_size, pc = 0;
+ uacpi_u8 *src, *dst;
+ void *resource_end;
+ uacpi_u16 base_aml_size;
+ uacpi_u32 base_aml_size_with_header, accumulator = 0;
+
+ insns = spec->to_native;
+
+ header_size = aml_resource_kind_to_header_size[spec->resource_kind];
+ resource->type = spec->native_type;
+ resource->length = native_size_for_aml_resource(data, aml_size, spec);
+ resource_end = ctx->byte_buf + spec->native_size;
+ ctx->byte_buf += resource->length;
+
+ base_aml_size = base_aml_size_with_header = spec->aml_size;
+ base_aml_size_with_header += header_size;
+
+ if (insns == UACPI_NULL)
+ return conditional_continue(ctx);
+
+ for (;;) {
+ insn = &insns[pc++];
+
+ src = data + insn->f1.aml_offset;
+ dst = NATIVE_OFFSET(resource, insn->f2.native_offset);
+
+ switch (insn->code) {
+ case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8:
+ case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16: {
+ uacpi_size i, j, max_bit;
+ uacpi_u16 value;
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16) {
+ max_bit = 16;
+ uacpi_memcpy(&value, src, sizeof(uacpi_u16));
+ } else {
+ max_bit = 8;
+ uacpi_memcpy_zerout(
+ &value, src, sizeof(value), sizeof(uacpi_u8)
+ );
+ }
+
+ for (i = 0, j = 0; i < max_bit; ++i) {
+ if (!(value & (1 << i)))
+ continue;
+
+ dst[j++] = i;
+ }
+
+ uacpi_memcpy(NATIVE_OFFSET(resource, insn->f3.arg2), &j, 1);
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6:{
+ uacpi_u8 mask, value;
+
+ mask = (insn->code - UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1) + 1;
+ mask = (1 << mask) - 1;
+
+ value = (*src >> insn->f3.imm) & mask;
+ uacpi_memcpy(dst, &value, sizeof(value));
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32:
+ accumulator = aml_size;
+ uacpi_memcpy(dst, &accumulator, 4);
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE:
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX:
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL: {
+ uacpi_size offset = 0, max_offset, length = 0;
+ uacpi_char *src_string, *dst_string;
+ union {
+ void *ptr;
+ uacpi_resource_source *source;
+ uacpi_resource_label *label;
+ } dst_name = { 0 };
+
+ dst_name.ptr = dst;
+
+ /*
+ * Check if the string is bounded by anything at the top. If not, we
+ * just assume it ends at the end of the resource.
+ */
+ if (insn->f3.arg2) {
+ uacpi_memcpy_zerout(&max_offset, data + insn->f3.arg2,
+ sizeof(max_offset), sizeof(uacpi_u16));
+ CHECK_AML_OFFSET(max_offset, "resource source");
+ } else {
+ max_offset = aml_size + header_size;
+ }
+
+ offset += base_aml_size_with_header;
+ offset += accumulator;
+
+ if (insn->code != UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL)
+ dst_name.source->index_present = UACPI_TRUE;
+
+ if (offset >= max_offset) {
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE)
+ dst_name.source->index_present = UACPI_FALSE;
+ break;
+ }
+
+ src_string = PTR_AT(data, offset);
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE) {
+ uacpi_memcpy(&dst_name.source->index, src_string++, 1);
+ offset++;
+ }
+
+ if (offset == max_offset)
+ break;
+
+ while (offset++ < max_offset) {
+ if (src_string[length++] == '\0')
+ break;
+ }
+
+ if (src_string[length - 1] != '\0') {
+ uacpi_error("non-null-terminated resource source string\n");
+ ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ dst_string = PTR_AT(resource_end, accumulator);
+ uacpi_memcpy(dst_string, src_string, length);
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL) {
+ dst_name.label->length = length;
+ dst_name.label->string = dst_string;
+ } else {
+ dst_name.source->length = length;
+ dst_name.source->string = dst_string;
+ }
+
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH:
+ uacpi_memcpy_zerout(&accumulator, src,
+ sizeof(accumulator), sizeof(uacpi_u16));
+ CHECK_AML_OFFSET(accumulator, "pin table");
+
+ accumulator -= base_aml_size_with_header;
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE: {
+ uacpi_u16 entry_count = accumulator / 2;
+
+ /*
+ * Pin table is stored right at the end of the resource buffer,
+ * copy the data there.
+ */
+ uacpi_memcpy(
+ resource_end,
+ data + base_aml_size_with_header,
+ accumulator
+ );
+
+ // Set pin_table_length
+ uacpi_memcpy(dst, &entry_count, sizeof(entry_count));
+
+ // Set pin_table pointer
+ uacpi_memcpy(NATIVE_OFFSET(resource, insn->f3.arg2),
+ &resource_end, sizeof(void*));
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA: {
+ uacpi_size length;
+ uacpi_u16 data_offset, offset_from_end;
+ void *native_dst, *vendor_data;
+
+ uacpi_memcpy(&data_offset, src, sizeof(data_offset));
+ CHECK_AML_OFFSET(data_offset, "vendor data");
+
+ vendor_data = data + data_offset;
+
+ /*
+ * Rebase the offset to cut off the header as it's not included
+ * in the size fields.
+ */
+ data_offset -= header_size;
+
+ length = aml_size - data_offset;
+ if (length == 0)
+ break;
+
+ uacpi_memcpy(dst, &length, sizeof(uacpi_u16));
+
+ offset_from_end = data_offset - base_aml_size;
+ native_dst = PTR_AT(resource_end, offset_from_end);
+
+ uacpi_memcpy(native_dst, vendor_data, length);
+ uacpi_memcpy(NATIVE_OFFSET(resource, insn->f3.arg2),
+ &native_dst, sizeof(void*));
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC: {
+ uacpi_resource_serial_bus_common *serial_bus_common;
+ uacpi_u8 serial_type, extra_size, type_length;
+
+ serial_bus_common = &resource->serial_bus_common;
+ serial_type = *src;
+ serial_bus_common->type = serial_type;
+ resource->type = aml_serial_to_native_type(serial_type);
+
+ /*
+ * Now that we know the serial type rebase the end pointers and
+ * sizes.
+ */
+ resource_end = PTR_AT(
+ resource_end,
+ aml_serial_resource_to_extra_native_size[serial_type]
+ );
+ extra_size = aml_serial_resource_to_extra_aml_size[serial_type];
+ base_aml_size += extra_size;
+ base_aml_size_with_header += extra_size;
+
+ type_length = serial_bus_common->type_data_length;
+ if (uacpi_unlikely(type_length < extra_size)) {
+ uacpi_error(
+ "invalid type-specific data length: %d, "
+ "expected at least %d\n", type_length, extra_size
+ );
+ ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ /*
+ * Calculate the length of the vendor data. All the extra data
+ * beyond the end of type-specific size is considered vendor data.
+ */
+ accumulator = type_length - extra_size;
+ if (accumulator == 0)
+ break;
+
+ serial_bus_common->vendor_data_length = accumulator;
+ serial_bus_common->vendor_data = resource_end;
+ uacpi_memcpy(
+ resource_end,
+ data + base_aml_size_with_header,
+ accumulator
+ );
+ break;
+ }
+
+ CONVERSION_OPCODES_COMMON(dst)
+ }
+ }
+}
+
+static uacpi_iteration_decision accumulate_native_buffer_size(
+ void *opaque, uacpi_u8 *data, uacpi_u16 resource_size,
+ const struct uacpi_resource_spec *spec
+)
+{
+ struct resource_conversion_ctx *ctx = opaque;
+ uacpi_size size_for_this;
+
+ size_for_this = native_size_for_aml_resource(data, resource_size, spec);
+ if (size_for_this == 0 || (ctx->size + size_for_this) < ctx->size) {
+ uacpi_error("invalid native size for aml resource: %zu\n",
+ size_for_this);
+ ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ ctx->size += size_for_this;
+ return conditional_continue(ctx);
+}
+
+static uacpi_status eval_resource_helper(
+ uacpi_namespace_node *node, const uacpi_char *method,
+ uacpi_object **out_obj
+)
+{
+ uacpi_status ret;
+ uacpi_bool is_device;
+
+ ret = uacpi_namespace_node_is(node, UACPI_OBJECT_DEVICE, &is_device);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely(!is_device))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ return uacpi_eval_simple_buffer(
+ node, method, out_obj
+ );
+}
+
+uacpi_status uacpi_native_resources_from_aml(
+ uacpi_data_view aml_buffer, uacpi_resources **out_resources
+)
+{
+ uacpi_status ret;
+ struct resource_conversion_ctx ctx = { 0 };
+ uacpi_resources *resources;
+
+ ret = uacpi_for_each_aml_resource(
+ aml_buffer, accumulate_native_buffer_size, &ctx
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely_error(ctx.st))
+ return ctx.st;
+
+ // Realistically any resource buffer bigger than this is probably a bug
+ if (uacpi_unlikely(ctx.size > (5 * 1024u * 1024u))) {
+ uacpi_error("bug: bogus native resource buffer size %zu\n", ctx.size);
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ resources = uacpi_kernel_alloc_zeroed(ctx.size + sizeof(uacpi_resources));
+ if (uacpi_unlikely(resources == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ resources->length = ctx.size;
+ resources->entries = UACPI_PTR_ADD(resources, sizeof(uacpi_resources));
+
+ uacpi_memzero(&ctx, sizeof(ctx));
+ ctx.buf = resources->entries;
+
+ ret = uacpi_for_each_aml_resource(aml_buffer, do_aml_resource_to_native, &ctx);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free_resources(resources);
+ return ret;
+ }
+
+ *out_resources = resources;
+ return ret;
+}
+
+uacpi_status uacpi_get_resource_from_buffer(
+ uacpi_data_view aml_buffer, uacpi_resource **out_resource
+)
+{
+ uacpi_status ret;
+ struct resource_conversion_ctx ctx = {
+ .just_one = UACPI_TRUE,
+ };
+ uacpi_resource *resource;
+
+ ret = uacpi_for_each_aml_resource(
+ aml_buffer, accumulate_native_buffer_size, &ctx
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ resource = uacpi_kernel_alloc_zeroed(ctx.size);
+ if (uacpi_unlikely(resource == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memzero(&ctx, sizeof(ctx));
+ ctx.buf = resource;
+ ctx.just_one = UACPI_TRUE;
+
+ ret = uacpi_for_each_aml_resource(aml_buffer, do_aml_resource_to_native, &ctx);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_free_resource(resource);
+ return ret;
+ }
+
+ *out_resource = resource;
+ return ret;
+}
+
+void uacpi_free_resources(uacpi_resources *resources)
+{
+ if (resources == UACPI_NULL)
+ return;
+
+ uacpi_free(resources, sizeof(uacpi_resources) + resources->length);
+}
+
+void uacpi_free_resource(uacpi_resource *resource)
+{
+ if (resource == UACPI_NULL)
+ return;
+
+ uacpi_free(resource, resource->length);
+}
+
+static uacpi_status extract_native_resources_from_method(
+ uacpi_namespace_node *device, const uacpi_char *method,
+ uacpi_resources **out_resources
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ uacpi_data_view buffer;
+
+ ret = eval_resource_helper(device, method, &obj);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ uacpi_buffer_to_view(obj->buffer, &buffer);
+
+ ret = uacpi_native_resources_from_aml(buffer, out_resources);
+ uacpi_object_unref(obj);
+
+ return ret;
+}
+
+uacpi_status uacpi_get_current_resources(
+ uacpi_namespace_node *device, uacpi_resources **out_resources
+)
+{
+ return extract_native_resources_from_method(device, "_CRS", out_resources);
+}
+
+uacpi_status uacpi_get_possible_resources(
+ uacpi_namespace_node *device, uacpi_resources **out_resources
+)
+{
+ return extract_native_resources_from_method(device, "_PRS", out_resources);
+}
+
+uacpi_status uacpi_get_device_resources(
+ uacpi_namespace_node *device, const uacpi_char *method,
+ uacpi_resources **out_resources
+)
+{
+ return extract_native_resources_from_method(device, method, out_resources);
+}
+
+uacpi_status uacpi_for_each_resource(
+ uacpi_resources *resources, uacpi_resource_iteration_callback cb, void *user
+)
+{
+ uacpi_size bytes_left = resources->length;
+ uacpi_resource *current = resources->entries;
+ uacpi_iteration_decision decision;
+
+ while (bytes_left) {
+ // At least the head bytes
+ if (uacpi_unlikely(bytes_left < 4)) {
+ uacpi_error("corrupted resource buffer %p length %zu\n",
+ resources, resources->length);
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_unlikely(current->type > UACPI_RESOURCE_TYPE_MAX)) {
+ uacpi_error("invalid resource type %d\n", current->type);
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ if (uacpi_unlikely(current->length > bytes_left)) {
+ uacpi_error("corrupted resource@%p length %u (%zu bytes left)\n",
+ current, current->length, bytes_left);
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ decision = cb(user, current);
+
+ if (decision == UACPI_ITERATION_DECISION_BREAK ||
+ current->type == UACPI_RESOURCE_TYPE_END_TAG)
+ return UACPI_STATUS_OK;
+
+ bytes_left -= current->length;
+ current = (uacpi_resource*)((uacpi_u8*)current + current->length);
+ }
+
+ return UACPI_STATUS_NO_RESOURCE_END_TAG;
+}
+
+uacpi_status uacpi_for_each_device_resource(
+ uacpi_namespace_node *device, const uacpi_char *method,
+ uacpi_resource_iteration_callback cb, void *user
+)
+{
+ uacpi_status ret;
+ uacpi_resources *resources;
+
+ ret = extract_native_resources_from_method(device, method, &resources);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_for_each_resource(resources, cb, user);
+ uacpi_free_resources(resources);
+
+ return ret;
+}
+
+static const struct uacpi_resource_spec *resource_spec_from_native(
+ uacpi_resource *resource
+)
+{
+ return &aml_resources[native_resource_to_type[resource->type]];
+}
+
+static uacpi_size aml_size_for_native_resource(
+ uacpi_resource *resource, const struct uacpi_resource_spec *spec
+)
+{
+ return spec->size_for_aml ?
+ spec->size_for_aml(spec, resource) :
+ aml_size_with_header(spec);
+}
+
+static uacpi_iteration_decision do_native_resource_to_aml(
+ void *opaque, uacpi_resource *resource
+)
+{
+ struct resource_conversion_ctx *ctx = opaque;
+ const struct uacpi_resource_spec *spec;
+ const struct uacpi_resource_convert_instruction *insns, *insn;
+ uacpi_u8 pc = 0;
+ uacpi_u8 *dst_base, *src, *dst;
+ uacpi_u32 aml_size, base_aml_size_with_header, accumulator = 0;
+ void *resource_end;
+
+ spec = resource_spec_from_native(resource);
+ aml_size = aml_size_for_native_resource(resource, spec);
+ insns = spec->to_aml;
+
+ dst_base = ctx->byte_buf;
+ ctx->byte_buf += aml_size;
+ aml_size -= aml_resource_kind_to_header_size[spec->resource_kind];
+
+ base_aml_size_with_header = spec->aml_size;
+ base_aml_size_with_header += aml_resource_kind_to_header_size[
+ spec->resource_kind
+ ];
+ resource_end = PTR_AT(resource, spec->native_size);
+
+ if (spec->resource_kind == UACPI_AML_RESOURCE_KIND_LARGE) {
+ *dst_base = ACPI_LARGE_ITEM | type_to_aml_resource[spec->type];
+ uacpi_memcpy(dst_base + 1, &aml_size, sizeof(uacpi_u16));
+ } else {
+ *dst_base = type_to_aml_resource[spec->type] << ACPI_SMALL_ITEM_NAME_IDX;
+ *dst_base |= aml_size;
+ }
+
+ if (insns == UACPI_NULL)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ for (;;) {
+ insn = &insns[pc++];
+
+ src = NATIVE_OFFSET(resource, insn->f2.native_offset);
+ dst = dst_base + insn->f1.aml_offset;
+
+ switch (insn->code) {
+ case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8:
+ case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16: {
+ uacpi_u8 i, *array_size, bytes = 1;
+ uacpi_u16 mask = 0;
+
+ array_size = NATIVE_OFFSET(resource, insn->f3.arg2);
+ for (i = 0; i < *array_size; ++i)
+ mask |= 1 << src[i];
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16)
+ bytes = 2;
+
+ uacpi_memcpy(dst, &mask, bytes);
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3:
+ case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6:
+ *dst |= *src << insn->f3.imm;
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32:
+ accumulator = aml_size;
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE:
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX:
+ case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL: {
+ uacpi_size source_offset, length;
+ uacpi_u8 *dst_string;
+ const uacpi_char *src_string;
+ union {
+ void *ptr;
+ uacpi_resource_source *source;
+ uacpi_resource_label *label;
+ } src_name = { 0 };
+
+ src_name.ptr = src;
+
+ source_offset = base_aml_size_with_header + accumulator;
+ dst_string = dst_base + source_offset;
+
+ if (insn->f1.aml_offset)
+ uacpi_memcpy(dst, &source_offset, sizeof(uacpi_u16));
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE &&
+ src_name.source->index_present)
+ uacpi_memcpy(dst_string++, &src_name.source->index, 1);
+
+ if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL) {
+ length = src_name.label->length;
+ src_string = src_name.label->string;
+ } else {
+ length = src_name.source->length;
+ src_string = src_name.source->string;
+ }
+
+ if (length == 0)
+ break;
+
+ if (uacpi_unlikely(src_string == UACPI_NULL)) {
+ uacpi_error(
+ "source string length is %zu but the pointer is NULL\n",
+ length
+ );
+ ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ uacpi_memcpy(dst_string, src_string, length);
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH:
+ uacpi_memcpy_zerout(&accumulator, src,
+ sizeof(accumulator), sizeof(uacpi_u16));
+ accumulator *= sizeof(uacpi_u16);
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE:
+ /*
+ * The pin table resides right at the end of the base resource,
+ * set the offset to it in the AML we're encoding.
+ */
+ uacpi_memcpy(dst, &base_aml_size_with_header, sizeof(uacpi_u16));
+
+ /*
+ * Copy the actual data. It also resides right at the end of the
+ * native base resource.
+ */
+ uacpi_memcpy(
+ dst_base + base_aml_size_with_header,
+ resource_end,
+ accumulator
+ );
+ break;
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA: {
+ uacpi_u16 vendor_data_length, data_offset, vendor_data_offset;
+ uacpi_u8 *vendor_data;
+
+ // Read the vendor_data pointer
+ uacpi_memcpy(&vendor_data, NATIVE_OFFSET(resource, insn->f3.arg2),
+ sizeof(void*));
+ uacpi_memcpy(&vendor_data_length, src, sizeof(uacpi_u16));
+
+ if (vendor_data == UACPI_NULL) {
+ uacpi_size full_aml_size;
+
+ if (uacpi_unlikely(vendor_data_length != 0)) {
+ uacpi_error(
+ "vendor_data_length is %d, but pointer is NULL\n",
+ vendor_data_length
+ );
+ ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ /*
+ * There's no vendor data. The specification still mandates
+ * that we fill the vendor data offset field correctly, meaning
+ * we set it to the total length of the resource.
+ */
+ full_aml_size = aml_size;
+ full_aml_size += aml_resource_kind_to_header_size[
+ spec->resource_kind
+ ];
+
+ uacpi_memcpy(dst, &full_aml_size, sizeof(uacpi_u16));
+ break;
+ }
+
+ /*
+ * Calculate the offset of vendor data from the end of the native
+ * resource and use it since it matches the offset from the end of
+ * the AML resource.
+ *
+ * Non-zero value means there's a source string in between.
+ */
+ data_offset = vendor_data - (uacpi_u8*)resource_end;
+ vendor_data_offset = data_offset + base_aml_size_with_header;
+
+ // Write vendor_data_offset
+ uacpi_memcpy(dst, &vendor_data_offset, sizeof(uacpi_u16));
+
+ /*
+ * Write vendor_data_length, this field is right after
+ * vendor_data_offset, and is completely redundant, but it exists
+ * nonetheless.
+ */
+ uacpi_memcpy(
+ dst + sizeof(uacpi_u16),
+ &vendor_data_length,
+ sizeof(vendor_data_length)
+ );
+
+ // Finally write the data itself
+ uacpi_memcpy(
+ dst_base + vendor_data_offset,
+ vendor_data,
+ vendor_data_length
+ );
+ break;
+ }
+
+ case UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC: {
+ uacpi_u8 serial_type = *src;
+ *dst = serial_type;
+
+ ctx->st = validate_aml_serial_type(serial_type);
+ if (uacpi_unlikely_error(ctx->st))
+ return UACPI_ITERATION_DECISION_BREAK;
+
+ if (uacpi_unlikely(resource->type !=
+ aml_serial_to_native_type(serial_type))) {
+ uacpi_error(
+ "native serial resource type %d doesn't match expected %d\n",
+ resource->type, aml_serial_to_native_type(serial_type)
+ );
+ ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ // Rebase the end pointer & size now that we know the serial type
+ resource_end = PTR_AT(
+ resource_end,
+ aml_serial_resource_to_extra_native_size[serial_type]
+ );
+ base_aml_size_with_header += aml_serial_resource_to_extra_aml_size[
+ serial_type
+ ];
+
+ accumulator = resource->serial_bus_common.vendor_data_length;
+ if (accumulator == 0)
+ break;
+
+ // Copy vendor data
+ uacpi_memcpy(
+ dst_base + base_aml_size_with_header,
+ resource_end,
+ accumulator
+ );
+ break;
+ }
+
+ CONVERSION_OPCODES_COMMON(src)
+ }
+ }
+}
+
+static uacpi_status native_resources_to_aml(
+ uacpi_resources *native_resources, void *aml_buffer
+)
+{
+ uacpi_status ret;
+ struct resource_conversion_ctx ctx = { 0 };
+
+ ctx.buf = aml_buffer;
+
+ ret = uacpi_for_each_resource(
+ native_resources, do_native_resource_to_aml, &ctx
+ );
+ if (ret == UACPI_STATUS_NO_RESOURCE_END_TAG) {
+ // An end tag is always included
+ uacpi_resource end_tag = { .type = UACPI_RESOURCE_TYPE_END_TAG };
+
+ do_native_resource_to_aml(&ctx, &end_tag);
+ ret = UACPI_STATUS_OK;
+ }
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ return ctx.st;
+}
+
+static uacpi_iteration_decision accumulate_aml_buffer_size(
+ void *opaque, uacpi_resource *resource
+)
+{
+ struct resource_conversion_ctx *ctx = opaque;
+ const struct uacpi_resource_spec *spec;
+ uacpi_size size_for_this;
+
+ // resource->type is sanitized to be valid here by the iteration function
+ spec = resource_spec_from_native(resource);
+
+ size_for_this = aml_size_for_native_resource(resource, spec);
+ if (size_for_this == 0 || (ctx->size + size_for_this) < ctx->size) {
+ uacpi_error("invalid aml size for native resource: %zu\n",
+ size_for_this);
+ ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ ctx->size += size_for_this;
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+uacpi_status uacpi_native_resources_to_aml(
+ uacpi_resources *resources, uacpi_object **out_template
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ void *buffer;
+ struct resource_conversion_ctx ctx = { 0 };
+
+ ret = uacpi_for_each_resource(
+ resources, accumulate_aml_buffer_size, &ctx
+ );
+ if (ret == UACPI_STATUS_NO_RESOURCE_END_TAG) {
+ // An end tag is always included
+ uacpi_resource end_tag = { .type = UACPI_RESOURCE_TYPE_END_TAG };
+
+ accumulate_aml_buffer_size(&ctx, &end_tag);
+ ret = UACPI_STATUS_OK;
+ }
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ if (uacpi_unlikely_error(ctx.st))
+ return ctx.st;
+
+ // Same reasoning as native_resource_from_aml
+ if (uacpi_unlikely(ctx.size > (5 * 1024u * 1024u))) {
+ uacpi_error("bug: bogus target aml resource buffer size %zu\n",
+ ctx.size);
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+
+ buffer = uacpi_kernel_alloc_zeroed(ctx.size);
+ if (uacpi_unlikely(buffer == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ obj = uacpi_create_object(UACPI_OBJECT_BUFFER);
+ if (uacpi_unlikely(obj == UACPI_NULL)) {
+ uacpi_free(buffer, ctx.size);
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ obj->buffer->data = buffer;
+ obj->buffer->size = ctx.size;
+
+ ret = native_resources_to_aml(resources, buffer);
+ if (uacpi_unlikely_error(ret))
+ uacpi_object_unref(obj);
+
+ if (ret == UACPI_STATUS_OK)
+ *out_template = obj;
+
+ return ret;
+}
+
+uacpi_status uacpi_set_resources(
+ uacpi_namespace_node *device, uacpi_resources *resources
+)
+{
+ uacpi_status ret;
+ uacpi_object *res_template;
+ uacpi_object_array args;
+
+ ret = uacpi_native_resources_to_aml(resources, &res_template);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ args.objects = &res_template;
+ args.count = 1;
+ ret = uacpi_eval(device, "_SRS", &args, UACPI_NULL);
+
+ uacpi_object_unref(res_template);
+ return ret;
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/shareable.c b/sys/dev/acpi/uacpi/shareable.c
new file mode 100644
index 0000000..b42660a
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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
diff --git a/sys/dev/acpi/uacpi/sleep.c b/sys/dev/acpi/uacpi/sleep.c
new file mode 100644
index 0000000..4736324
--- /dev/null
+++ b/sys/dev/acpi/uacpi/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: {
+ uacpi_pci_address address = { 0 };
+
+ // Bus is assumed to be 0 here
+ address.segment = 0;
+ address.bus = 0;
+ address.device = (reset_reg->address >> 32) & 0xFF;
+ address.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
diff --git a/sys/dev/acpi/uacpi/stdlib.c b/sys/dev/acpi/uacpi/stdlib.c
new file mode 100644
index 0000000..98344f1
--- /dev/null
+++ b/sys/dev/acpi/uacpi/stdlib.c
@@ -0,0 +1,728 @@
+#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
+
+#elif defined(__WATCOMC__)
+ // TODO: Use compiler intrinsics or inline ASM here
+ uacpi_u8 index;
+ uacpi_u64 mask = 1;
+
+ for (index = 1; index <= 64; index++, mask <<= 1) {
+ if (value & mask) {
+ return index;
+ }
+ }
+
+ return 0;
+#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
+
+#elif defined(__WATCOMC__)
+ // TODO: Use compiler intrinsics or inline ASM here
+ uacpi_u8 index;
+ uacpi_u64 mask = (1ull << 63);
+
+ for (index = 64; index > 0; index--, mask >>= 1) {
+ if (value & mask) {
+ return index;
+ }
+ }
+
+ return 0;
+#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 = { 0 };
+ uacpi_u64 value;
+ const uacpi_char *next_conversion;
+ uacpi_size next_offset;
+ uacpi_char flag;
+
+ fb_state.buffer = buffer;
+ fb_state.capacity = capacity;
+ fb_state.bytes_written = 0;
+
+ 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
diff --git a/sys/dev/acpi/uacpi/tables.c b/sys/dev/acpi/uacpi/tables.c
new file mode 100644
index 0000000..df7d7b9
--- /dev/null
+++ b/sys/dev/acpi/uacpi/tables.c
@@ -0,0 +1,1399 @@
+#include <uacpi/internal/tables.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/interpreter.h>
+#include <uacpi/internal/mutex.h>
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(
+ table_array, struct uacpi_installed_table, UACPI_STATIC_TABLE_ARRAY_LEN
+)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ table_array, struct uacpi_installed_table, static
+)
+
+static struct table_array tables;
+static uacpi_bool early_table_access;
+static uacpi_table_installation_handler installation_handler;
+
+#ifndef UACPI_BAREBONES_MODE
+
+static uacpi_handle table_mutex;
+
+#define ENSURE_TABLES_ONLINE() \
+ do { \
+ if (!early_table_access) \
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST( \
+ UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED \
+ ); \
+ } while (0)
+
+#else
+
+/*
+ * Use a dummy function instead of a macro to prevent the following error:
+ * error: statement with no effect [-Werror=unused-value]
+ */
+static inline uacpi_status dummy_mutex_acquire_release(uacpi_handle mtx)
+{
+ UACPI_UNUSED(mtx);
+ return UACPI_STATUS_OK;
+}
+
+#define table_mutex UACPI_NULL
+#define uacpi_acquire_native_mutex_may_be_null dummy_mutex_acquire_release
+#define uacpi_release_native_mutex_may_be_null dummy_mutex_acquire_release
+
+#define ENSURE_TABLES_ONLINE() \
+ do { \
+ if (!early_table_access) \
+ return UACPI_STATUS_INIT_LEVEL_MISMATCH; \
+ } while (0)
+
+#endif // !UACPI_BAREBONES_MODE
+
+static uacpi_status table_install_physical_with_origin_unlocked(
+ uacpi_phys_addr phys, enum uacpi_table_origin origin,
+ const uacpi_char *expected_signature, uacpi_table *out_table
+);
+static uacpi_status table_install_with_origin_unlocked(
+ void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+);
+
+UACPI_PACKED(struct uacpi_rxsdt {
+ struct acpi_sdt_hdr hdr;
+ uacpi_u8 ptr_bytes[];
+})
+
+static void dump_table_header(
+ uacpi_phys_addr phys_addr, void *hdr
+)
+{
+ struct acpi_sdt_hdr *sdt = hdr;
+
+ if (uacpi_signatures_match(hdr, ACPI_FACS_SIGNATURE)) {
+ uacpi_info(
+ "FACS 0x%016"UACPI_PRIX64" %08X\n", UACPI_FMT64(phys_addr),
+ sdt->length
+ );
+ return;
+ }
+
+ if (!uacpi_memcmp(hdr, ACPI_RSDP_SIGNATURE, sizeof(ACPI_RSDP_SIGNATURE) - 1)) {
+ struct acpi_rsdp *rsdp = hdr;
+
+ uacpi_info(
+ "RSDP 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s)\n",
+ UACPI_FMT64(phys_addr), rsdp->revision >= 2 ? rsdp->length : 20,
+ rsdp->revision, rsdp->oemid
+ );
+ return;
+ }
+
+ uacpi_info(
+ "%.4s 0x%016"UACPI_PRIX64" %08X v%02X (%6.6s %8.8s)\n",
+ sdt->signature, UACPI_FMT64(phys_addr), sdt->length, sdt->revision,
+ sdt->oemid, sdt->oem_table_id
+ );
+}
+
+static uacpi_status initialize_from_rxsdt(uacpi_phys_addr rxsdt_addr,
+ uacpi_size entry_size)
+{
+ struct uacpi_rxsdt *rxsdt;
+ uacpi_size i, entry_bytes, map_len = sizeof(*rxsdt);
+ uacpi_phys_addr entry_addr;
+ uacpi_status ret;
+
+ rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
+ if (rxsdt == UACPI_NULL)
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ dump_table_header(rxsdt_addr, rxsdt);
+
+ ret = uacpi_check_table_signature(rxsdt,
+ entry_size == 8 ? ACPI_XSDT_SIGNATURE : ACPI_RSDT_SIGNATURE);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ map_len = rxsdt->hdr.length;
+ uacpi_kernel_unmap(rxsdt, sizeof(*rxsdt));
+
+ if (uacpi_unlikely(map_len < (sizeof(*rxsdt) + entry_size)))
+ return UACPI_STATUS_INVALID_TABLE_LENGTH;
+
+ // Make sure length is aligned to entry size so we don't OOB
+ entry_bytes = map_len - sizeof(*rxsdt);
+ entry_bytes &= ~(entry_size - 1);
+
+ rxsdt = uacpi_kernel_map(rxsdt_addr, map_len);
+ if (uacpi_unlikely(rxsdt == UACPI_NULL))
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ ret = uacpi_verify_table_checksum(rxsdt, map_len);
+ if (uacpi_unlikely_error(ret))
+ goto error_out;
+
+ for (i = 0; i < entry_bytes; i += entry_size) {
+ uacpi_u64 entry_phys_addr_large = 0;
+ uacpi_memcpy(&entry_phys_addr_large, &rxsdt->ptr_bytes[i], entry_size);
+
+ if (!entry_phys_addr_large)
+ continue;
+
+ entry_addr = uacpi_truncate_phys_addr_with_warn(entry_phys_addr_large);
+ ret = uacpi_table_install_physical_with_origin(
+ entry_addr, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL, UACPI_NULL
+ );
+ if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+ ret != UACPI_STATUS_OVERRIDDEN))
+ goto error_out;
+ }
+
+ ret = UACPI_STATUS_OK;
+
+error_out:
+ uacpi_kernel_unmap(rxsdt, map_len);
+ return ret;
+}
+
+static uacpi_status initialize_from_rsdp(void)
+{
+ uacpi_status ret;
+ uacpi_phys_addr rsdp_phys;
+ struct acpi_rsdp *rsdp;
+ uacpi_phys_addr rxsdt;
+ uacpi_size rxsdt_entry_size;
+
+ g_uacpi_rt_ctx.is_rev1 = UACPI_TRUE;
+
+ ret = uacpi_kernel_get_rsdp(&rsdp_phys);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ rsdp = uacpi_kernel_map(rsdp_phys, sizeof(struct acpi_rsdp));
+ if (rsdp == UACPI_NULL)
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ dump_table_header(rsdp_phys, rsdp);
+
+ if (rsdp->revision > 1 && rsdp->xsdt_addr &&
+ !uacpi_check_flag(UACPI_FLAG_BAD_XSDT))
+ {
+ rxsdt = uacpi_truncate_phys_addr_with_warn(rsdp->xsdt_addr);
+ rxsdt_entry_size = 8;
+ } else {
+ rxsdt = (uacpi_phys_addr)rsdp->rsdt_addr;
+ rxsdt_entry_size = 4;
+ }
+
+ uacpi_kernel_unmap(rsdp, sizeof(struct acpi_rsdp));
+
+ if (!rxsdt) {
+ uacpi_error("both RSDT & XSDT tables are NULL!\n");
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+
+ return initialize_from_rxsdt(rxsdt, rxsdt_entry_size);
+}
+
+uacpi_status uacpi_setup_early_table_access(
+ void *temporary_buffer, uacpi_size buffer_size
+)
+{
+ uacpi_status ret;
+
+#ifndef UACPI_BAREBONES_MODE
+ UACPI_ENSURE_INIT_LEVEL_IS(UACPI_INIT_LEVEL_EARLY);
+#endif
+ if (uacpi_unlikely(early_table_access))
+ return UACPI_STATUS_INIT_LEVEL_MISMATCH;
+
+ if (uacpi_unlikely(buffer_size < sizeof(struct uacpi_installed_table)))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ uacpi_logger_initialize();
+
+ tables.dynamic_storage = temporary_buffer;
+ tables.dynamic_capacity = buffer_size / sizeof(struct uacpi_installed_table);
+ early_table_access = UACPI_TRUE;
+
+ ret = initialize_from_rsdp();
+ if (uacpi_unlikely_error(ret))
+ uacpi_deinitialize_tables();
+
+ return ret;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+static uacpi_iteration_decision warn_if_early_referenced(
+ void *user, struct uacpi_installed_table *tbl, uacpi_size idx
+)
+{
+ UACPI_UNUSED(user);
+
+ if (uacpi_unlikely(tbl->reference_count != 0)) {
+ uacpi_warn(
+ "table "UACPI_PRI_TBL_HDR" (%zu) still has %d early reference(s)!\n",
+ UACPI_FMT_TBL_HDR(&tbl->hdr), idx, tbl->reference_count
+ );
+ }
+
+ return UACPI_ITERATION_DECISION_CONTINUE;
+}
+
+uacpi_status uacpi_initialize_tables(void)
+{
+ if (early_table_access) {
+ uacpi_size num_tables;
+
+ uacpi_for_each_table(0, warn_if_early_referenced, UACPI_NULL);
+
+ // Reallocate the user buffer into a normal heap array
+ num_tables = table_array_size(&tables);
+ if (num_tables > table_array_inline_capacity(&tables)) {
+ void *new_buf;
+
+ /*
+ * Allocate a new buffer with size equal to exactly the number of
+ * dynamic tables (that live in the user provided temporary buffer).
+ */
+ num_tables -= table_array_inline_capacity(&tables);
+ new_buf = uacpi_kernel_alloc(
+ sizeof(struct uacpi_installed_table) * num_tables
+ );
+ if (uacpi_unlikely(new_buf == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy(new_buf, tables.dynamic_storage,
+ sizeof(struct uacpi_installed_table) * num_tables);
+ tables.dynamic_storage = new_buf;
+ tables.dynamic_capacity = num_tables;
+ } else {
+ /*
+ * User-provided temporary buffer was not used at all, just remove
+ * any references to it.
+ */
+ tables.dynamic_storage = UACPI_NULL;
+ tables.dynamic_capacity = 0;
+ }
+
+ early_table_access = UACPI_FALSE;
+ } else {
+ uacpi_status ret;
+
+ ret = initialize_from_rsdp();
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ if (!uacpi_is_hardware_reduced()) {
+ struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+ uacpi_table tbl;
+
+ if (fadt->x_firmware_ctrl) {
+ uacpi_status ret;
+
+ ret = table_install_physical_with_origin_unlocked(
+ fadt->x_firmware_ctrl, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
+ ACPI_FACS_SIGNATURE, &tbl
+ );
+ if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+ ret != UACPI_STATUS_OVERRIDDEN))
+ return ret;
+
+ g_uacpi_rt_ctx.facs = tbl.ptr;
+ }
+ }
+
+ table_mutex = uacpi_kernel_create_mutex();
+ if (uacpi_unlikely(table_mutex == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ return UACPI_STATUS_OK;
+}
+#endif // !UACPI_BAREBONES_MODE
+
+void uacpi_deinitialize_tables(void)
+{
+ uacpi_size i;
+
+ for (i = 0; i < table_array_size(&tables); ++i) {
+ struct uacpi_installed_table *tbl = table_array_at(&tables, i);
+
+ switch (tbl->origin) {
+#ifndef UACPI_BAREBONES_MODE
+ case UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL:
+ uacpi_free(tbl->ptr, tbl->hdr.length);
+ break;
+#endif
+ case UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL:
+ case UACPI_TABLE_ORIGIN_HOST_PHYSICAL:
+ if (tbl->reference_count != 0)
+ uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (early_table_access) {
+ uacpi_memzero(&tables, sizeof(tables));
+ early_table_access = UACPI_FALSE;
+ } else {
+ table_array_clear(&tables);
+ }
+
+ installation_handler = UACPI_NULL;
+
+#ifndef UACPI_BAREBONES_MODE
+ if (table_mutex)
+ uacpi_kernel_free_mutex(table_mutex);
+
+ table_mutex = UACPI_NULL;
+#endif
+}
+
+uacpi_status uacpi_set_table_installation_handler(
+ uacpi_table_installation_handler handler
+)
+{
+ uacpi_status ret;
+
+ ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (installation_handler != UACPI_NULL && handler != UACPI_NULL)
+ goto out;
+
+ installation_handler = handler;
+
+out:
+ uacpi_release_native_mutex_may_be_null(table_mutex);
+ return ret;
+}
+
+static uacpi_status initialize_fadt(const void*);
+
+static uacpi_u8 table_checksum(void *table, uacpi_size size)
+{
+ uacpi_u8 *bytes = table;
+ uacpi_u8 csum = 0;
+ uacpi_size i;
+
+ for (i = 0; i < size; ++i)
+ csum += bytes[i];
+
+ return csum;
+}
+
+uacpi_status uacpi_verify_table_checksum(void *table, uacpi_size size)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ uacpi_u8 csum;
+
+ csum = table_checksum(table, size);
+
+ if (uacpi_unlikely(csum != 0)) {
+ enum uacpi_log_level lvl = UACPI_LOG_WARN;
+ struct acpi_sdt_hdr *hdr = table;
+
+ if (uacpi_check_flag(UACPI_FLAG_BAD_CSUM_FATAL)) {
+ ret = UACPI_STATUS_BAD_CHECKSUM;
+ lvl = UACPI_LOG_ERROR;
+ }
+
+ uacpi_log_lvl(
+ lvl, "invalid table "UACPI_PRI_TBL_HDR" checksum %d!\n",
+ UACPI_FMT_TBL_HDR(hdr), csum
+ );
+ }
+
+ return ret;
+}
+
+uacpi_bool uacpi_signatures_match(const void *const lhs, const void *const rhs)
+{
+ return uacpi_memcmp(lhs, rhs, sizeof(uacpi_object_name)) == 0;
+}
+
+uacpi_status uacpi_check_table_signature(void *table, const uacpi_char *expect)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (!uacpi_signatures_match(table, expect)) {
+ enum uacpi_log_level lvl = UACPI_LOG_WARN;
+ struct acpi_sdt_hdr *hdr = table;
+
+ if (uacpi_check_flag(UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL)) {
+ ret = UACPI_STATUS_INVALID_SIGNATURE;
+ lvl = UACPI_LOG_ERROR;
+ }
+
+ uacpi_log_lvl(
+ lvl,
+ "invalid table "UACPI_PRI_TBL_HDR" signature (expected '%.4s')\n",
+ UACPI_FMT_TBL_HDR(hdr), expect
+ );
+ }
+
+ return ret;
+}
+
+static uacpi_status table_alloc(
+ struct uacpi_installed_table **out_tbl, uacpi_size *out_idx
+)
+{
+ struct uacpi_installed_table *tbl;
+
+ if (early_table_access &&
+ table_array_size(&tables) == table_array_capacity(&tables)) {
+ uacpi_warn("early table access buffer capacity exhausted!\n");
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ tbl = table_array_alloc(&tables);
+ if (uacpi_unlikely(tbl == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ *out_tbl = tbl;
+ *out_idx = table_array_size(&tables) - 1;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status get_external_table_header(
+ uacpi_phys_addr phys_addr, struct acpi_sdt_hdr *out_hdr
+)
+{
+ void *virt;
+
+ virt = uacpi_kernel_map(phys_addr, sizeof(*out_hdr));
+ if (uacpi_unlikely(virt == UACPI_NULL))
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ uacpi_memcpy(out_hdr, virt, sizeof(*out_hdr));
+
+ uacpi_kernel_unmap(virt, sizeof(*out_hdr));
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status table_ref_unlocked(struct uacpi_installed_table *tbl)
+{
+ switch (tbl->reference_count) {
+ case 0: {
+ uacpi_status ret;
+
+ if (tbl->flags & UACPI_TABLE_INVALID)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
+ tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
+ break;
+
+ tbl->ptr = uacpi_kernel_map(tbl->phys_addr, tbl->hdr.length);
+ if (uacpi_unlikely(tbl->ptr == UACPI_NULL))
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ if (!(tbl->flags & UACPI_TABLE_CSUM_VERIFIED)) {
+ ret = uacpi_verify_table_checksum(tbl->ptr, tbl->hdr.length);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+ tbl->flags |= UACPI_TABLE_INVALID;
+ tbl->ptr = UACPI_NULL;
+ return ret;
+ }
+
+ tbl->flags |= UACPI_TABLE_CSUM_VERIFIED;
+ }
+ break;
+ }
+ case 0xFFFF - 1:
+ uacpi_warn(
+ "too many references for "UACPI_PRI_TBL_HDR
+ ", mapping permanently\n", UACPI_FMT_TBL_HDR(&tbl->hdr)
+ );
+ break;
+ default:
+ break;
+ }
+
+ if (uacpi_likely(tbl->reference_count != 0xFFFF))
+ tbl->reference_count++;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status table_unref_unlocked(struct uacpi_installed_table *tbl)
+{
+ switch (tbl->reference_count) {
+ case 0:
+ uacpi_warn(
+ "tried to unref table "UACPI_PRI_TBL_HDR" with no references\n",
+ UACPI_FMT_TBL_HDR(&tbl->hdr)
+ );
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ case 1:
+ if (tbl->origin != UACPI_TABLE_ORIGIN_HOST_PHYSICAL &&
+ tbl->origin != UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL)
+ break;
+
+ uacpi_kernel_unmap(tbl->ptr, tbl->hdr.length);
+ tbl->ptr = UACPI_NULL;
+ break;
+ case 0xFFFF:
+ /*
+ * Consider the reference count (overflow) of 0xFFFF to be a permanently
+ * mapped table as we don't know the actual number of references.
+ */
+ return UACPI_STATUS_OK;
+ default:
+ break;
+ }
+
+ tbl->reference_count--;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status verify_and_install_table(
+ struct acpi_sdt_hdr *hdr, uacpi_phys_addr phys_addr, void *virt_addr,
+ enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+ struct uacpi_installed_table *table;
+ uacpi_bool is_fadt;
+ uacpi_size idx;
+ uacpi_u8 flags = 0;
+
+ is_fadt = uacpi_signatures_match(hdr->signature, ACPI_FADT_SIGNATURE);
+
+ /*
+ * FACS is the only(?) table without a checksum because it has OSPM
+ * writable fields. Don't try to validate it here.
+ */
+ if (uacpi_signatures_match(hdr->signature, ACPI_FACS_SIGNATURE)) {
+ flags |= UACPI_TABLE_CSUM_VERIFIED;
+ } else if (uacpi_check_flag(UACPI_FLAG_PROACTIVE_TBL_CSUM) || is_fadt ||
+ out_table != UACPI_NULL) {
+ void *mapping = virt_addr;
+
+ // We may already have a valid mapping, reuse it if we do
+ if (mapping == UACPI_NULL)
+ mapping = uacpi_kernel_map(phys_addr, hdr->length);
+ if (uacpi_unlikely(mapping == UACPI_NULL))
+ return UACPI_STATUS_MAPPING_FAILED;
+
+ ret = uacpi_verify_table_checksum(mapping, hdr->length);
+ if (uacpi_likely_success(ret)) {
+ if (is_fadt)
+ ret = initialize_fadt(mapping);
+ flags |= UACPI_TABLE_CSUM_VERIFIED;
+ }
+
+ if (virt_addr == UACPI_NULL)
+ uacpi_kernel_unmap(mapping, hdr->length);
+
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ if (uacpi_signatures_match(hdr->signature, ACPI_DSDT_SIGNATURE))
+ g_uacpi_rt_ctx.is_rev1 = hdr->revision < 2;
+
+ ret = table_alloc(&table, &idx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ dump_table_header(phys_addr, hdr);
+
+ uacpi_memcpy(&table->hdr, hdr, sizeof(*hdr));
+ table->reference_count = 0;
+ table->phys_addr = phys_addr;
+ table->ptr = virt_addr;
+ table->flags = flags;
+ table->origin = origin;
+
+ if (out_table == UACPI_NULL)
+ return UACPI_STATUS_OK;
+
+ table->reference_count++;
+ out_table->ptr = virt_addr;
+ out_table->index = idx;
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status handle_table_override(
+ uacpi_table_installation_disposition disposition, uacpi_u64 address,
+ uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+
+ switch (disposition) {
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_VIRTUAL_OVERRIDE:
+ ret = table_install_with_origin_unlocked(
+ UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)address),
+ UACPI_TABLE_ORIGIN_HOST_VIRTUAL,
+ out_table
+ );
+ return ret;
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_PHYSICAL_OVERRIDE:
+ return table_install_physical_with_origin_unlocked(
+ (uacpi_phys_addr)address,
+ UACPI_TABLE_ORIGIN_HOST_PHYSICAL,
+ UACPI_NULL,
+ out_table
+ );
+ default:
+ uacpi_error("invalid table installation disposition %d\n", disposition);
+ return UACPI_STATUS_INTERNAL_ERROR;
+ }
+}
+
+static uacpi_status table_install_physical_with_origin_unlocked(
+ uacpi_phys_addr phys, enum uacpi_table_origin origin,
+ const uacpi_char *expected_signature, uacpi_table *out_table
+)
+{
+ struct acpi_sdt_hdr hdr;
+ void *virt = UACPI_NULL;
+ uacpi_status ret;
+
+ ret = get_external_table_header(phys, &hdr);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely(hdr.length < sizeof(struct acpi_sdt_hdr))) {
+ uacpi_error("invalid table '%.4s' (0x%016"UACPI_PRIX64") size: %u\n",
+ hdr.signature, UACPI_FMT64(phys), hdr.length);
+ return UACPI_STATUS_INVALID_TABLE_LENGTH;
+ }
+
+ if (expected_signature != UACPI_NULL) {
+ ret = uacpi_check_table_signature(&hdr, expected_signature);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+ }
+
+ if (installation_handler != UACPI_NULL || out_table != UACPI_NULL) {
+ virt = uacpi_kernel_map(phys, hdr.length);
+ if (uacpi_unlikely(!virt))
+ return UACPI_STATUS_MAPPING_FAILED;
+ }
+
+ if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL &&
+ installation_handler != UACPI_NULL) {
+ uacpi_u64 override;
+ uacpi_table_installation_disposition disposition;
+
+ disposition = installation_handler(virt, &override);
+
+ switch (disposition) {
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
+ break;
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
+ uacpi_info(
+ "table '%.4s' (0x%016"UACPI_PRIX64") installation denied "
+ "by host\n", hdr.signature, UACPI_FMT64(phys)
+ );
+ ret = UACPI_STATUS_DENIED;
+ goto out;
+
+ default:
+ uacpi_info(
+ "table '%.4s' (0x%016"UACPI_PRIX64") installation "
+ "overridden by host\n", hdr.signature, UACPI_FMT64(phys)
+ );
+
+ ret = handle_table_override(disposition, override, out_table);
+ if (uacpi_likely_success(ret))
+ ret = UACPI_STATUS_OVERRIDDEN;
+
+ goto out;
+ }
+ }
+
+ ret = verify_and_install_table(&hdr, phys, virt, origin, out_table);
+out:
+ // We don't unmap only in this case
+ if (ret == UACPI_STATUS_OK && out_table != UACPI_NULL)
+ return ret;
+
+ if (virt != UACPI_NULL)
+ uacpi_kernel_unmap(virt, hdr.length);
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_table_install_physical_with_origin(
+ uacpi_phys_addr phys, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+
+ ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = table_install_physical_with_origin_unlocked(
+ phys, origin, UACPI_NULL, out_table
+ );
+ uacpi_release_native_mutex_may_be_null(table_mutex);
+
+ return ret;
+}
+
+static uacpi_status table_install_with_origin_unlocked(
+ void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+ struct acpi_sdt_hdr *hdr = virt;
+
+ if (uacpi_unlikely(hdr->length < sizeof(struct acpi_sdt_hdr))) {
+ uacpi_error("invalid table '%.4s' (%p) size: %u\n",
+ hdr->signature, virt, hdr->length);
+ return UACPI_STATUS_INVALID_TABLE_LENGTH;
+ }
+
+#ifndef UACPI_BAREBONES_MODE
+ if (origin == UACPI_TABLE_ORIGIN_FIRMWARE_VIRTUAL &&
+ installation_handler != UACPI_NULL) {
+ uacpi_u64 override;
+ uacpi_table_installation_disposition disposition;
+
+ disposition = installation_handler(virt, &override);
+
+ switch (disposition) {
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_ALLOW:
+ break;
+ case UACPI_TABLE_INSTALLATION_DISPOSITON_DENY:
+ uacpi_info(
+ "table "UACPI_PRI_TBL_HDR" installation denied by host\n",
+ UACPI_FMT_TBL_HDR(hdr)
+ );
+ return UACPI_STATUS_DENIED;
+
+ default: {
+ uacpi_status ret;
+ uacpi_info(
+ "table "UACPI_PRI_TBL_HDR" installation overridden by host\n",
+ UACPI_FMT_TBL_HDR(hdr)
+ );
+
+ ret = handle_table_override(disposition, override, out_table);
+ if (uacpi_likely_success(ret))
+ ret = UACPI_STATUS_OVERRIDDEN;
+
+ return ret;
+ }
+ }
+ }
+#endif
+
+ return verify_and_install_table(
+ hdr, 0, virt, origin, out_table
+ );
+}
+
+uacpi_status uacpi_table_install_with_origin(
+ void *virt, enum uacpi_table_origin origin, uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+
+ ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = table_install_with_origin_unlocked(virt, origin, out_table);
+
+ uacpi_release_native_mutex_may_be_null(table_mutex);
+ return ret;
+}
+
+uacpi_status uacpi_table_install(void *virt, uacpi_table *out_table)
+{
+ ENSURE_TABLES_ONLINE();
+
+ return uacpi_table_install_with_origin(
+ virt, UACPI_TABLE_ORIGIN_HOST_VIRTUAL, out_table
+ );
+}
+
+uacpi_status uacpi_table_install_physical(
+ uacpi_phys_addr addr, uacpi_table *out_table
+)
+{
+ ENSURE_TABLES_ONLINE();
+
+ return uacpi_table_install_physical_with_origin(
+ addr, UACPI_TABLE_ORIGIN_HOST_PHYSICAL, out_table
+ );
+}
+
+uacpi_status uacpi_for_each_table(
+ uacpi_size base_idx, uacpi_table_iteration_callback cb, void *user
+)
+{
+ uacpi_status ret;
+ uacpi_size idx;
+ struct uacpi_installed_table *tbl;
+ uacpi_iteration_decision dec;
+
+ ENSURE_TABLES_ONLINE();
+
+ ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ for (idx = base_idx; idx < table_array_size(&tables); ++idx) {
+ tbl = table_array_at(&tables, idx);
+
+ if (tbl->flags & UACPI_TABLE_INVALID)
+ continue;
+
+ dec = cb(user, tbl, idx);
+ if (dec == UACPI_ITERATION_DECISION_BREAK)
+ break;
+ }
+
+ uacpi_release_native_mutex_may_be_null(table_mutex);
+ return ret;
+}
+
+enum search_type {
+ SEARCH_TYPE_BY_ID,
+ SEARCH_TYPE_MATCH,
+};
+
+struct table_search_ctx {
+ union {
+ const uacpi_table_identifiers *id;
+ uacpi_table_match_callback match_cb;
+ };
+
+ uacpi_table *out_table;
+ uacpi_u8 search_type;
+ uacpi_status status;
+};
+
+static uacpi_iteration_decision do_search_tables(
+ void *user, struct uacpi_installed_table *tbl, uacpi_size idx
+)
+{
+ struct table_search_ctx *ctx = user;
+ uacpi_table *out_table;
+ uacpi_status ret;
+
+ switch (ctx->search_type) {
+ case SEARCH_TYPE_BY_ID: {
+ const uacpi_table_identifiers *id = ctx->id;
+
+ if (!uacpi_signatures_match(&id->signature, tbl->hdr.signature))
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ if (id->oemid[0] != '\0' &&
+ uacpi_memcmp(id->oemid, tbl->hdr.oemid, sizeof(id->oemid)) != 0)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ if (id->oem_table_id[0] != '\0' &&
+ uacpi_memcmp(id->oem_table_id, tbl->hdr.oem_table_id,
+ sizeof(id->oem_table_id)) != 0)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ break;
+ }
+
+ case SEARCH_TYPE_MATCH:
+ if (!ctx->match_cb(tbl))
+ return UACPI_ITERATION_DECISION_CONTINUE;
+ break;
+
+ default:
+ ctx->status = UACPI_STATUS_INVALID_ARGUMENT;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ ret = table_ref_unlocked(tbl);
+ if (uacpi_likely_success(ret)) {
+ out_table = ctx->out_table;
+ out_table->ptr = tbl->ptr;
+ out_table->index = idx;
+ ctx->status = ret;
+ return UACPI_ITERATION_DECISION_BREAK;
+ }
+
+ /*
+ * Don't abort nor propagate bad checksums, just pretend this table never
+ * existed and go on with the search.
+ */
+ if (ret == UACPI_STATUS_BAD_CHECKSUM)
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ ctx->status = ret;
+ return UACPI_ITERATION_DECISION_BREAK;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+uacpi_status uacpi_table_match(
+ uacpi_size base_idx, uacpi_table_match_callback cb, uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+ struct table_search_ctx ctx = { 0 };
+
+ ctx.match_cb = cb;
+ ctx.search_type = SEARCH_TYPE_MATCH;
+ ctx.out_table = out_table;
+ ctx.status = UACPI_STATUS_NOT_FOUND;
+
+ ret = uacpi_for_each_table(base_idx, do_search_tables, &ctx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ return ctx.status;
+}
+#endif
+
+static uacpi_status find_table(
+ uacpi_size base_idx, const uacpi_table_identifiers *id,
+ uacpi_table *out_table
+)
+{
+ uacpi_status ret;
+ struct table_search_ctx ctx = { 0 };
+
+ ctx.id = id;
+ ctx.out_table = out_table;
+ ctx.search_type = SEARCH_TYPE_BY_ID;
+ ctx.status = UACPI_STATUS_NOT_FOUND;
+
+ ret = uacpi_for_each_table(base_idx, do_search_tables, &ctx);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ return ctx.status;
+}
+
+uacpi_status uacpi_table_find_by_signature(
+ const uacpi_char *signature_string, struct uacpi_table *out_table
+)
+{
+ struct uacpi_table_identifiers id = { 0 };
+
+ id.signature.text[0] = signature_string[0];
+ id.signature.text[1] = signature_string[1];
+ id.signature.text[2] = signature_string[2];
+ id.signature.text[3] = signature_string[3];
+
+ ENSURE_TABLES_ONLINE();
+
+ return find_table(0, &id, out_table);
+}
+
+uacpi_status uacpi_table_find_next_with_same_signature(
+ uacpi_table *in_out_table
+)
+{
+ struct uacpi_table_identifiers id = { 0 };
+
+ ENSURE_TABLES_ONLINE();
+
+ if (uacpi_unlikely(in_out_table->ptr == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ uacpi_memcpy(&id.signature, in_out_table->hdr->signature,
+ sizeof(id.signature));
+ uacpi_table_unref(in_out_table);
+
+ return find_table(in_out_table->index + 1, &id, in_out_table);
+}
+
+uacpi_status uacpi_table_find(
+ const uacpi_table_identifiers *id, uacpi_table *out_table
+)
+{
+ ENSURE_TABLES_ONLINE();
+
+ return find_table(0, id, out_table);
+}
+
+#define TABLE_CTL_SET_FLAGS (1 << 0)
+#define TABLE_CTL_CLEAR_FLAGS (1 << 1)
+#define TABLE_CTL_VALIDATE_SET_FLAGS (1 << 2)
+#define TABLE_CTL_VALIDATE_CLEAR_FLAGS (1 << 3)
+#define TABLE_CTL_GET (1 << 4)
+#define TABLE_CTL_PUT (1 << 5)
+
+struct table_ctl_request {
+ uacpi_u8 type;
+
+ uacpi_u8 expect_set;
+ uacpi_u8 expect_clear;
+ uacpi_u8 set;
+ uacpi_u8 clear;
+
+ void *out_tbl;
+};
+
+static uacpi_status table_ctl(uacpi_size idx, struct table_ctl_request *req)
+{
+ uacpi_status ret;
+ struct uacpi_installed_table *tbl;
+
+ ENSURE_TABLES_ONLINE();
+
+ ret = uacpi_acquire_native_mutex_may_be_null(table_mutex);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ if (uacpi_unlikely(table_array_size(&tables) <= idx)) {
+ uacpi_error(
+ "requested invalid table index %zu (%zu tables installed)\n",
+ idx, table_array_size(&tables)
+ );
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+
+ tbl = table_array_at(&tables, idx);
+ if (uacpi_unlikely(tbl->flags & UACPI_TABLE_INVALID))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (req->type & TABLE_CTL_VALIDATE_SET_FLAGS) {
+ uacpi_u8 mask = req->expect_set;
+
+ if (uacpi_unlikely((tbl->flags & mask) != mask)) {
+ uacpi_error(
+ "unexpected table '%.4s' flags %02X, expected %02X to be set\n",
+ tbl->hdr.signature, tbl->flags, mask
+ );
+ ret = UACPI_STATUS_INVALID_ARGUMENT;
+ goto out;
+ }
+ }
+
+ if (req->type & TABLE_CTL_VALIDATE_CLEAR_FLAGS) {
+ uacpi_u8 mask = req->expect_clear;
+
+ if (uacpi_unlikely((tbl->flags & mask) != 0)) {
+ uacpi_error(
+ "unexpected table '%.4s' flags %02X, expected %02X "
+ "to be clear\n", tbl->hdr.signature, tbl->flags, mask
+ );
+ ret = UACPI_STATUS_ALREADY_EXISTS;
+ goto out;
+ }
+ }
+
+ if (req->type & TABLE_CTL_GET) {
+ ret = table_ref_unlocked(tbl);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+
+ req->out_tbl = tbl->ptr;
+ }
+
+ if (req->type & TABLE_CTL_PUT) {
+ ret = table_unref_unlocked(tbl);
+ if (uacpi_unlikely_error(ret))
+ goto out;
+ }
+
+ if (req->type & TABLE_CTL_SET_FLAGS)
+ tbl->flags |= req->set;
+ if (req->type & TABLE_CTL_CLEAR_FLAGS)
+ tbl->flags &= ~req->clear;
+
+out:
+ uacpi_release_native_mutex_may_be_null(table_mutex);
+ return ret;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+uacpi_status uacpi_table_load_with_cause(
+ uacpi_size idx, enum uacpi_table_load_cause cause
+)
+{
+ uacpi_status ret;
+ struct table_ctl_request req = {
+ .type = TABLE_CTL_SET_FLAGS | TABLE_CTL_VALIDATE_CLEAR_FLAGS |
+ TABLE_CTL_GET,
+ .set = UACPI_TABLE_LOADED,
+ .expect_clear = UACPI_TABLE_LOADED,
+ };
+
+ ret = table_ctl(idx, &req);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_execute_table(req.out_tbl, cause);
+
+ req.type = TABLE_CTL_PUT;
+ table_ctl(idx, &req);
+ return ret;
+}
+
+uacpi_status uacpi_table_load(uacpi_size idx)
+{
+ return uacpi_table_load_with_cause(idx, UACPI_TABLE_LOAD_CAUSE_HOST);
+}
+
+void uacpi_table_mark_as_loaded(uacpi_size idx)
+{
+ struct table_ctl_request req = {
+ .type = TABLE_CTL_SET_FLAGS, .set = UACPI_TABLE_LOADED
+ };
+
+ table_ctl(idx, &req);
+}
+#endif // !UACPI_BAREBONES_MODE
+
+uacpi_status uacpi_table_ref(uacpi_table *tbl)
+{
+ struct table_ctl_request req = {
+ .type = TABLE_CTL_GET
+ };
+
+ return table_ctl(tbl->index, &req);
+}
+
+uacpi_status uacpi_table_unref(uacpi_table *tbl)
+{
+ struct table_ctl_request req = {
+ .type = TABLE_CTL_PUT
+ };
+
+ return table_ctl(tbl->index, &req);
+}
+
+uacpi_u16 fadt_version_sizes[] = {
+ 116, 132, 244, 244, 268, 276
+};
+
+static void fadt_ensure_correct_revision(struct acpi_fadt *fadt)
+{
+ uacpi_size current_rev, rev;
+
+ current_rev = fadt->hdr.revision;
+
+ for (rev = 0; rev < UACPI_ARRAY_SIZE(fadt_version_sizes); ++rev) {
+ if (fadt->hdr.length <= fadt_version_sizes[rev])
+ break;
+ }
+
+ if (rev == UACPI_ARRAY_SIZE(fadt_version_sizes)) {
+ uacpi_trace(
+ "FADT revision (%zu) is likely greater than the last "
+ "supported, reducing to %zu\n", current_rev, rev
+ );
+ fadt->hdr.revision = rev;
+ return;
+ }
+
+ rev++;
+
+ if (current_rev != rev && !(rev == 3 && current_rev == 4)) {
+ uacpi_warn(
+ "FADT length %u doesn't match expected for revision %zu, "
+ "assuming version %zu\n", fadt->hdr.length, current_rev,
+ rev
+ );
+ fadt->hdr.revision = rev;
+ }
+}
+
+static void gas_init_system_io(
+ struct acpi_gas *gas, uacpi_u64 address, uacpi_u8 byte_size
+)
+{
+ gas->address = address;
+ gas->address_space_id = UACPI_ADDRESS_SPACE_SYSTEM_IO;
+ gas->register_bit_width = UACPI_MIN(255, byte_size * 8);
+ gas->register_bit_offset = 0;
+ gas->access_size = 0;
+}
+
+
+struct register_description {
+ uacpi_size offset, xoffset;
+ uacpi_size length_offset;
+};
+
+#define fadt_offset(field) uacpi_offsetof(struct acpi_fadt, field)
+
+/*
+ * We convert all the legacy registers into GAS format and write them into
+ * the x_* fields for convenience and faster access at runtime.
+ */
+static struct register_description fadt_registers[] = {
+ {
+ .offset = fadt_offset(pm1a_evt_blk),
+ .xoffset = fadt_offset(x_pm1a_evt_blk),
+ .length_offset = fadt_offset(pm1_evt_len),
+ },
+ {
+ .offset = fadt_offset(pm1b_evt_blk),
+ .xoffset = fadt_offset(x_pm1b_evt_blk),
+ .length_offset = fadt_offset(pm1_evt_len),
+ },
+ {
+ .offset = fadt_offset(pm1a_cnt_blk),
+ .xoffset = fadt_offset(x_pm1a_cnt_blk),
+ .length_offset = fadt_offset(pm1_cnt_len),
+ },
+ {
+ .offset = fadt_offset(pm1b_cnt_blk),
+ .xoffset = fadt_offset(x_pm1b_cnt_blk),
+ .length_offset = fadt_offset(pm1_cnt_len),
+ },
+ {
+ .offset = fadt_offset(pm2_cnt_blk),
+ .xoffset = fadt_offset(x_pm2_cnt_blk),
+ .length_offset = fadt_offset(pm2_cnt_len),
+ },
+ {
+ .offset = fadt_offset(pm_tmr_blk),
+ .xoffset = fadt_offset(x_pm_tmr_blk),
+ .length_offset = fadt_offset(pm_tmr_len),
+ },
+ {
+ .offset = fadt_offset(gpe0_blk),
+ .xoffset = fadt_offset(x_gpe0_blk),
+ .length_offset = fadt_offset(gpe0_blk_len),
+ },
+ {
+ .offset = fadt_offset(gpe1_blk),
+ .xoffset = fadt_offset(x_gpe1_blk),
+ .length_offset = fadt_offset(gpe1_blk_len),
+ },
+};
+
+static void *fadt_relative(uacpi_size offset)
+{
+ return ((uacpi_u8*)&g_uacpi_rt_ctx.fadt) + offset;
+}
+
+static void convert_registers_to_gas(void)
+{
+ uacpi_size i;
+ struct register_description *desc;
+ struct acpi_gas *gas;
+ uacpi_u32 legacy_addr;
+ uacpi_u8 length;
+
+ for (i = 0; i < UACPI_ARRAY_SIZE(fadt_registers); ++i) {
+ desc = &fadt_registers[i];
+
+ legacy_addr = *(uacpi_u32*)fadt_relative(desc->offset);
+ length = *(uacpi_u8*)fadt_relative(desc->length_offset);
+ gas = fadt_relative(desc->xoffset);
+
+ if (gas->address)
+ continue;
+
+ gas_init_system_io(gas, legacy_addr, length);
+ }
+}
+
+#ifndef UACPI_BAREBONES_MODE
+static void split_one_block(
+ struct acpi_gas *src, struct acpi_gas *dst0, struct acpi_gas *dst1
+)
+{
+ uacpi_size byte_length;
+
+ if (src->address == 0)
+ return;
+
+ byte_length = src->register_bit_width / 8;
+ byte_length /= 2;
+
+ gas_init_system_io(dst0, src->address, byte_length);
+ gas_init_system_io(dst1, src->address + byte_length, byte_length);
+}
+
+static void split_event_blocks(void)
+{
+ split_one_block(
+ &g_uacpi_rt_ctx.fadt.x_pm1a_evt_blk,
+ &g_uacpi_rt_ctx.pm1a_status_blk,
+ &g_uacpi_rt_ctx.pm1a_enable_blk
+ );
+ split_one_block(
+ &g_uacpi_rt_ctx.fadt.x_pm1b_evt_blk,
+ &g_uacpi_rt_ctx.pm1b_status_blk,
+ &g_uacpi_rt_ctx.pm1b_enable_blk
+ );
+}
+#endif // !UACPI_BAREBONES_MODE
+
+static uacpi_status initialize_fadt(const void *virt)
+{
+ uacpi_status ret;
+ struct acpi_fadt *fadt = &g_uacpi_rt_ctx.fadt;
+ const struct acpi_sdt_hdr *hdr = virt;
+
+ /*
+ * Here we (roughly) follow ACPICA initialization sequence to make sure we
+ * handle potential BIOS quirks with garbage inside FADT correctly.
+ */
+
+ uacpi_memcpy(fadt, hdr, UACPI_MIN(sizeof(*fadt), hdr->length));
+
+#if !defined(UACPI_REDUCED_HARDWARE) && !defined(UACPI_BAREBONES_MODE)
+ g_uacpi_rt_ctx.is_hardware_reduced = fadt->flags & ACPI_HW_REDUCED_ACPI;
+#endif
+
+ fadt_ensure_correct_revision(fadt);
+
+ /*
+ * These are reserved prior to version 3, so zero them out to work around
+ * BIOS implementations that might dirty these.
+ */
+ if (fadt->hdr.revision <= 2) {
+ fadt->preferred_pm_profile = 0;
+ fadt->pstate_cnt = 0;
+ fadt->cst_cnt = 0;
+ fadt->iapc_boot_arch = 0;
+ }
+
+ if (!fadt->x_dsdt)
+ fadt->x_dsdt = fadt->dsdt;
+
+ if (fadt->x_dsdt) {
+ ret = table_install_physical_with_origin_unlocked(
+ fadt->x_dsdt, UACPI_TABLE_ORIGIN_FIRMWARE_PHYSICAL,
+ ACPI_DSDT_SIGNATURE, UACPI_NULL
+ );
+ if (uacpi_unlikely(ret != UACPI_STATUS_OK &&
+ ret != UACPI_STATUS_OVERRIDDEN))
+ return ret;
+ }
+
+ /*
+ * Unconditionally use 32 bit FACS if it exists, as 64 bit FACS is known
+ * to cause issues on some firmware:
+ * https://bugzilla.kernel.org/show_bug.cgi?id=74021
+ *
+ * Note that we don't install it here as FACS needs permanent mapping, which
+ * we might not be able to obtain at this point in case of early table
+ * access.
+ */
+ if (fadt->firmware_ctrl)
+ fadt->x_firmware_ctrl = fadt->firmware_ctrl;
+
+ if (!uacpi_is_hardware_reduced()) {
+ convert_registers_to_gas();
+#ifndef UACPI_BAREBONES_MODE
+ split_event_blocks();
+#endif
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_table_fadt(struct acpi_fadt **out_fadt)
+{
+ ENSURE_TABLES_ONLINE();
+
+ *out_fadt = &g_uacpi_rt_ctx.fadt;
+ return UACPI_STATUS_OK;
+}
diff --git a/sys/dev/acpi/uacpi/types.c b/sys/dev/acpi/uacpi/types.c
new file mode 100644
index 0000000..840d3ef
--- /dev/null
+++ b/sys/dev/acpi/uacpi/types.c
@@ -0,0 +1,1489 @@
+#include <uacpi/types.h>
+#include <uacpi/internal/types.h>
+#include <uacpi/internal/stdlib.h>
+#include <uacpi/internal/shareable.h>
+#include <uacpi/internal/dynamic_array.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/namespace.h>
+#include <uacpi/internal/tables.h>
+#include <uacpi/kernel_api.h>
+
+const uacpi_char *uacpi_address_space_to_string(
+ enum uacpi_address_space space
+)
+{
+ switch (space) {
+ case UACPI_ADDRESS_SPACE_SYSTEM_MEMORY:
+ return "SystemMemory";
+ case UACPI_ADDRESS_SPACE_SYSTEM_IO:
+ return "SystemIO";
+ case UACPI_ADDRESS_SPACE_PCI_CONFIG:
+ return "PCI_Config";
+ case UACPI_ADDRESS_SPACE_EMBEDDED_CONTROLLER:
+ return "EmbeddedControl";
+ case UACPI_ADDRESS_SPACE_SMBUS:
+ return "SMBus";
+ case UACPI_ADDRESS_SPACE_SYSTEM_CMOS:
+ return "SystemCMOS";
+ case UACPI_ADDRESS_SPACE_PCI_BAR_TARGET:
+ return "PciBarTarget";
+ case UACPI_ADDRESS_SPACE_IPMI:
+ return "IPMI";
+ case UACPI_ADDRESS_SPACE_GENERAL_PURPOSE_IO:
+ return "GeneralPurposeIO";
+ case UACPI_ADDRESS_SPACE_GENERIC_SERIAL_BUS:
+ return "GenericSerialBus";
+ case UACPI_ADDRESS_SPACE_PCC:
+ return "PCC";
+ case UACPI_ADDRESS_SPACE_PRM:
+ return "PlatformRtMechanism";
+ case UACPI_ADDRESS_SPACE_FFIXEDHW:
+ return "FFixedHW";
+ case UACPI_ADDRESS_SPACE_TABLE_DATA:
+ return "TableData";
+ default:
+ return "<vendor specific>";
+ }
+}
+
+#ifndef UACPI_BAREBONES_MODE
+
+const uacpi_char *uacpi_object_type_to_string(uacpi_object_type type)
+{
+ switch (type) {
+ case UACPI_OBJECT_UNINITIALIZED:
+ return "Uninitialized";
+ case UACPI_OBJECT_INTEGER:
+ return "Integer";
+ case UACPI_OBJECT_STRING:
+ return "String";
+ case UACPI_OBJECT_BUFFER:
+ return "Buffer";
+ case UACPI_OBJECT_PACKAGE:
+ return "Package";
+ case UACPI_OBJECT_FIELD_UNIT:
+ return "Field Unit";
+ case UACPI_OBJECT_DEVICE:
+ return "Device";
+ case UACPI_OBJECT_EVENT:
+ return "Event";
+ case UACPI_OBJECT_REFERENCE:
+ return "Reference";
+ case UACPI_OBJECT_BUFFER_INDEX:
+ return "Buffer Index";
+ case UACPI_OBJECT_METHOD:
+ return "Method";
+ case UACPI_OBJECT_MUTEX:
+ return "Mutex";
+ case UACPI_OBJECT_OPERATION_REGION:
+ return "Operation Region";
+ case UACPI_OBJECT_POWER_RESOURCE:
+ return "Power Resource";
+ case UACPI_OBJECT_PROCESSOR:
+ return "Processor";
+ case UACPI_OBJECT_THERMAL_ZONE:
+ return "Thermal Zone";
+ case UACPI_OBJECT_BUFFER_FIELD:
+ return "Buffer Field";
+ case UACPI_OBJECT_DEBUG:
+ return "Debug";
+ default:
+ return "<Invalid type>";
+ }
+}
+
+static uacpi_bool buffer_alloc(uacpi_object *obj, uacpi_size initial_size)
+{
+ uacpi_buffer *buf;
+
+ buf = uacpi_kernel_alloc_zeroed(sizeof(uacpi_buffer));
+ if (uacpi_unlikely(buf == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(buf);
+
+ if (initial_size) {
+ buf->data = uacpi_kernel_alloc(initial_size);
+ if (uacpi_unlikely(buf->data == UACPI_NULL)) {
+ uacpi_free(buf, sizeof(*buf));
+ return UACPI_FALSE;
+ }
+
+ buf->size = initial_size;
+ }
+
+ obj->buffer = buf;
+ return UACPI_TRUE;
+}
+
+static uacpi_bool empty_buffer_or_string_alloc(uacpi_object *object)
+{
+ return buffer_alloc(object, 0);
+}
+
+uacpi_bool uacpi_package_fill(
+ uacpi_package *pkg, uacpi_size num_elements,
+ enum uacpi_prealloc_objects prealloc_objects
+)
+{
+ uacpi_size i;
+
+ if (uacpi_unlikely(num_elements == 0))
+ return UACPI_TRUE;
+
+ pkg->objects = uacpi_kernel_alloc_zeroed(
+ num_elements * sizeof(uacpi_handle)
+ );
+ if (uacpi_unlikely(pkg->objects == UACPI_NULL))
+ return UACPI_FALSE;
+
+ pkg->count = num_elements;
+
+ if (prealloc_objects == UACPI_PREALLOC_OBJECTS_YES) {
+ for (i = 0; i < num_elements; ++i) {
+ pkg->objects[i] = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+
+ if (uacpi_unlikely(pkg->objects[i] == UACPI_NULL))
+ return UACPI_FALSE;
+ }
+ }
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool package_alloc(
+ uacpi_object *obj, uacpi_size initial_size,
+ enum uacpi_prealloc_objects prealloc
+)
+{
+ uacpi_package *pkg;
+
+ pkg = uacpi_kernel_alloc_zeroed(sizeof(uacpi_package));
+ if (uacpi_unlikely(pkg == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(pkg);
+
+ if (uacpi_unlikely(!uacpi_package_fill(pkg, initial_size, prealloc))) {
+ uacpi_free(pkg, sizeof(*pkg));
+ return UACPI_FALSE;
+ }
+
+ obj->package = pkg;
+ return UACPI_TRUE;
+}
+
+static uacpi_bool empty_package_alloc(uacpi_object *object)
+{
+ return package_alloc(object, 0, UACPI_PREALLOC_OBJECTS_NO);
+}
+
+uacpi_mutex *uacpi_create_mutex(void)
+{
+ uacpi_mutex *mutex;
+
+ mutex = uacpi_kernel_alloc_zeroed(sizeof(uacpi_mutex));
+ if (uacpi_unlikely(mutex == UACPI_NULL))
+ return UACPI_NULL;
+
+ mutex->owner = UACPI_THREAD_ID_NONE;
+
+ mutex->handle = uacpi_kernel_create_mutex();
+ if (mutex->handle == UACPI_NULL) {
+ uacpi_free(mutex, sizeof(*mutex));
+ return UACPI_NULL;
+ }
+
+ uacpi_shareable_init(mutex);
+ return mutex;
+}
+
+static uacpi_bool mutex_alloc(uacpi_object *obj)
+{
+ obj->mutex = uacpi_create_mutex();
+ return obj->mutex != UACPI_NULL;
+}
+
+static uacpi_bool event_alloc(uacpi_object *obj)
+{
+ uacpi_event *event;
+
+ event = uacpi_kernel_alloc_zeroed(sizeof(uacpi_event));
+ if (uacpi_unlikely(event == UACPI_NULL))
+ return UACPI_FALSE;
+
+ event->handle = uacpi_kernel_create_event();
+ if (event->handle == UACPI_NULL) {
+ uacpi_free(event, sizeof(*event));
+ return UACPI_FALSE;
+ }
+
+ uacpi_shareable_init(event);
+ obj->event = event;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool method_alloc(uacpi_object *obj)
+{
+ uacpi_control_method *method;
+
+ method = uacpi_kernel_alloc_zeroed(sizeof(*method));
+ if (uacpi_unlikely(method == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(method);
+ obj->method = method;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool op_region_alloc(uacpi_object *obj)
+{
+ uacpi_operation_region *op_region;
+
+ op_region = uacpi_kernel_alloc_zeroed(sizeof(*op_region));
+ if (uacpi_unlikely(op_region == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(op_region);
+ obj->op_region = op_region;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool field_unit_alloc(uacpi_object *obj)
+{
+ uacpi_field_unit *field_unit;
+
+ field_unit = uacpi_kernel_alloc_zeroed(sizeof(*field_unit));
+ if (uacpi_unlikely(field_unit == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(field_unit);
+ obj->field_unit = field_unit;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool processor_alloc(uacpi_object *obj)
+{
+ uacpi_processor *processor;
+
+ processor = uacpi_kernel_alloc_zeroed(sizeof(*processor));
+ if (uacpi_unlikely(processor == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(processor);
+ obj->processor = processor;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool device_alloc(uacpi_object *obj)
+{
+ uacpi_device *device;
+
+ device = uacpi_kernel_alloc_zeroed(sizeof(*device));
+ if (uacpi_unlikely(device == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(device);
+ obj->device = device;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_bool thermal_zone_alloc(uacpi_object *obj)
+{
+ uacpi_thermal_zone *thermal_zone;
+
+ thermal_zone = uacpi_kernel_alloc_zeroed(sizeof(*thermal_zone));
+ if (uacpi_unlikely(thermal_zone == UACPI_NULL))
+ return UACPI_FALSE;
+
+ uacpi_shareable_init(thermal_zone);
+ obj->thermal_zone = thermal_zone;
+
+ return UACPI_TRUE;
+}
+
+typedef uacpi_bool (*object_ctor)(uacpi_object *obj);
+
+static object_ctor object_constructor_table[UACPI_OBJECT_MAX_TYPE_VALUE + 1] = {
+ [UACPI_OBJECT_STRING] = empty_buffer_or_string_alloc,
+ [UACPI_OBJECT_BUFFER] = empty_buffer_or_string_alloc,
+ [UACPI_OBJECT_PACKAGE] = empty_package_alloc,
+ [UACPI_OBJECT_FIELD_UNIT] = field_unit_alloc,
+ [UACPI_OBJECT_MUTEX] = mutex_alloc,
+ [UACPI_OBJECT_EVENT] = event_alloc,
+ [UACPI_OBJECT_OPERATION_REGION] = op_region_alloc,
+ [UACPI_OBJECT_METHOD] = method_alloc,
+ [UACPI_OBJECT_PROCESSOR] = processor_alloc,
+ [UACPI_OBJECT_DEVICE] = device_alloc,
+ [UACPI_OBJECT_THERMAL_ZONE] = thermal_zone_alloc,
+};
+
+uacpi_object *uacpi_create_object(uacpi_object_type type)
+{
+ uacpi_object *ret;
+ object_ctor ctor;
+
+ ret = uacpi_kernel_alloc_zeroed(sizeof(*ret));
+ if (uacpi_unlikely(ret == UACPI_NULL))
+ return ret;
+
+ uacpi_shareable_init(ret);
+ ret->type = type;
+
+ ctor = object_constructor_table[type];
+ if (ctor == UACPI_NULL)
+ return ret;
+
+ if (uacpi_unlikely(!ctor(ret))) {
+ uacpi_free(ret, sizeof(*ret));
+ return UACPI_NULL;
+ }
+
+ return ret;
+}
+
+static void free_buffer(uacpi_handle handle)
+{
+ uacpi_buffer *buf = handle;
+
+ if (buf->data != UACPI_NULL)
+ /*
+ * If buffer has a size of 0 but a valid data pointer it's probably an
+ * "empty" buffer allocated by the interpreter in make_null_buffer
+ * and its real size is actually 1.
+ */
+ uacpi_free(buf->data, UACPI_MAX(buf->size, 1));
+
+ uacpi_free(buf, sizeof(*buf));
+}
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(free_queue, uacpi_package*, 4)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(free_queue, uacpi_package*, static)
+
+static uacpi_bool free_queue_push(struct free_queue *queue, uacpi_package *pkg)
+{
+ uacpi_package **slot;
+
+ slot = free_queue_alloc(queue);
+ if (uacpi_unlikely(slot == UACPI_NULL))
+ return UACPI_FALSE;
+
+ *slot = pkg;
+ return UACPI_TRUE;
+}
+
+static void free_object(uacpi_object *obj);
+
+// No references allowed here, only plain objects
+static void free_plain_no_recurse(uacpi_object *obj, struct free_queue *queue)
+{
+ switch (obj->type) {
+ case UACPI_OBJECT_PACKAGE:
+ if (uacpi_shareable_unref(obj->package) > 1)
+ break;
+
+ if (uacpi_unlikely(!free_queue_push(queue,
+ obj->package))) {
+ uacpi_warn(
+ "unable to free nested package @%p: not enough memory\n",
+ obj->package
+ );
+ }
+
+ // Don't call free_object here as that will recurse
+ uacpi_free(obj, sizeof(*obj));
+ break;
+ default:
+ /*
+ * This call is guaranteed to not recurse further as we handle
+ * recursive cases elsewhere explicitly.
+ */
+ free_object(obj);
+ }
+}
+
+static void unref_plain_no_recurse(uacpi_object *obj, struct free_queue *queue)
+{
+ if (uacpi_shareable_unref(obj) > 1)
+ return;
+
+ free_plain_no_recurse(obj, queue);
+}
+
+static void unref_chain_no_recurse(uacpi_object *obj, struct free_queue *queue)
+{
+ uacpi_object *next_obj = UACPI_NULL;
+
+ while (obj) {
+ if (obj->type == UACPI_OBJECT_REFERENCE)
+ next_obj = obj->inner_object;
+
+ if (uacpi_shareable_unref(obj) > 1)
+ goto do_next;
+
+ if (obj->type == UACPI_OBJECT_REFERENCE) {
+ uacpi_free(obj, sizeof(*obj));
+ } else {
+ free_plain_no_recurse(obj, queue);
+ }
+
+ do_next:
+ obj = next_obj;
+ next_obj = UACPI_NULL;
+ }
+}
+
+static void unref_object_no_recurse(uacpi_object *obj, struct free_queue *queue)
+{
+ if (obj->type == UACPI_OBJECT_REFERENCE) {
+ unref_chain_no_recurse(obj, queue);
+ return;
+ }
+
+ unref_plain_no_recurse(obj, queue);
+}
+
+static void free_package(uacpi_handle handle)
+{
+ struct free_queue queue = { 0 };
+ uacpi_package *pkg = handle;
+ uacpi_object *obj;
+ uacpi_size i;
+
+ free_queue_push(&queue, pkg);
+
+ while (free_queue_size(&queue) != 0) {
+ pkg = *free_queue_last(&queue);
+ free_queue_pop(&queue);
+
+ /*
+ * 1. Unref/free every object in the package. Note that this might add
+ * even more packages into the free queue.
+ */
+ for (i = 0; i < pkg->count; ++i) {
+ obj = pkg->objects[i];
+ unref_object_no_recurse(obj, &queue);
+ }
+
+ // 2. Release the object array
+ uacpi_free(pkg->objects, sizeof(*pkg->objects) * pkg->count);
+
+ // 3. Release the package itself
+ uacpi_free(pkg, sizeof(*pkg));
+ }
+
+ free_queue_clear(&queue);
+}
+
+static void free_mutex(uacpi_handle handle)
+{
+ uacpi_mutex *mutex = handle;
+
+ uacpi_kernel_free_mutex(mutex->handle);
+ uacpi_free(mutex, sizeof(*mutex));
+}
+
+void uacpi_mutex_unref(uacpi_mutex *mutex)
+{
+ if (mutex == UACPI_NULL)
+ return;
+
+ uacpi_shareable_unref_and_delete_if_last(mutex, free_mutex);
+}
+
+static void free_event(uacpi_handle handle)
+{
+ uacpi_event *event = handle;
+
+ uacpi_kernel_free_event(event->handle);
+ uacpi_free(event, sizeof(*event));
+}
+
+static void free_address_space_handler(uacpi_handle handle)
+{
+ uacpi_address_space_handler *handler = handle;
+ uacpi_free(handler, sizeof(*handler));
+}
+
+static void free_address_space_handlers(
+ uacpi_address_space_handler *handler
+)
+{
+ uacpi_address_space_handler *next_handler;
+
+ while (handler) {
+ next_handler = handler->next;
+ uacpi_shareable_unref_and_delete_if_last(
+ handler, free_address_space_handler
+ );
+ handler = next_handler;
+ }
+}
+
+static void free_device_notify_handlers(uacpi_device_notify_handler *handler)
+{
+ uacpi_device_notify_handler *next_handler;
+
+ while (handler) {
+ next_handler = handler->next;
+ uacpi_free(handler, sizeof(*handler));
+ handler = next_handler;
+ }
+}
+
+static void free_handlers(uacpi_handle handle)
+{
+ uacpi_handlers *handlers = handle;
+
+ free_address_space_handlers(handlers->address_space_head);
+ free_device_notify_handlers(handlers->notify_head);
+}
+
+void uacpi_address_space_handler_unref(uacpi_address_space_handler *handler)
+{
+ uacpi_shareable_unref_and_delete_if_last(
+ handler, free_address_space_handler
+ );
+}
+
+static void free_op_region(uacpi_handle handle)
+{
+ uacpi_operation_region *op_region = handle;
+
+ if (uacpi_unlikely(op_region->handler != UACPI_NULL)) {
+ uacpi_warn(
+ "BUG: attempting to free an opregion@%p with a handler attached\n",
+ op_region
+ );
+ }
+
+ switch (op_region->space) {
+ case UACPI_ADDRESS_SPACE_PCC:
+ uacpi_free(op_region->internal_buffer, op_region->length);
+ break;
+ case UACPI_ADDRESS_SPACE_TABLE_DATA: {
+ struct uacpi_table table = { 0 };
+
+ table.index = op_region->table_idx;
+ uacpi_table_unref(
+ &table
+ );
+ break;
+ }
+ default:
+ break;
+ }
+
+ uacpi_free(op_region, sizeof(*op_region));
+}
+
+static void free_device(uacpi_handle handle)
+{
+ uacpi_device *device = handle;
+ free_handlers(device);
+ uacpi_free(device, sizeof(*device));
+}
+
+static void free_processor(uacpi_handle handle)
+{
+ uacpi_processor *processor = handle;
+ free_handlers(processor);
+ uacpi_free(processor, sizeof(*processor));
+}
+
+static void free_thermal_zone(uacpi_handle handle)
+{
+ uacpi_thermal_zone *thermal_zone = handle;
+ free_handlers(thermal_zone);
+ uacpi_free(thermal_zone, sizeof(*thermal_zone));
+}
+
+static void free_field_unit(uacpi_handle handle)
+{
+ uacpi_field_unit *field_unit = handle;
+
+ if (field_unit->connection)
+ uacpi_object_unref(field_unit->connection);
+
+ switch (field_unit->kind) {
+ case UACPI_FIELD_UNIT_KIND_NORMAL:
+ uacpi_namespace_node_unref(field_unit->region);
+ break;
+ case UACPI_FIELD_UNIT_KIND_BANK:
+ uacpi_namespace_node_unref(field_unit->bank_region);
+ uacpi_shareable_unref_and_delete_if_last(
+ field_unit->bank_selection, free_field_unit
+ );
+ break;
+ case UACPI_FIELD_UNIT_KIND_INDEX:
+ uacpi_shareable_unref_and_delete_if_last(
+ field_unit->index, free_field_unit
+ );
+ uacpi_shareable_unref_and_delete_if_last(
+ field_unit->data, free_field_unit
+ );
+ break;
+ default:
+ break;
+ }
+
+ uacpi_free(field_unit, sizeof(*field_unit));
+}
+
+static void free_method(uacpi_handle handle)
+{
+ uacpi_control_method *method = handle;
+
+ uacpi_shareable_unref_and_delete_if_last(
+ method->mutex, free_mutex
+ );
+
+ if (!method->native_call && method->owns_code)
+ uacpi_free(method->code, method->size);
+ uacpi_free(method, sizeof(*method));
+}
+
+void uacpi_method_unref(uacpi_control_method *method)
+{
+ uacpi_shareable_unref_and_delete_if_last(method, free_method);
+}
+
+static void free_object_storage(uacpi_object *obj)
+{
+ switch (obj->type) {
+ case UACPI_OBJECT_STRING:
+ case UACPI_OBJECT_BUFFER:
+ uacpi_shareable_unref_and_delete_if_last(obj->buffer, free_buffer);
+ break;
+ case UACPI_OBJECT_BUFFER_FIELD:
+ uacpi_shareable_unref_and_delete_if_last(obj->buffer_field.backing,
+ free_buffer);
+ break;
+ case UACPI_OBJECT_BUFFER_INDEX:
+ uacpi_shareable_unref_and_delete_if_last(obj->buffer_index.buffer,
+ free_buffer);
+ break;
+ case UACPI_OBJECT_METHOD:
+ uacpi_method_unref(obj->method);
+ break;
+ case UACPI_OBJECT_PACKAGE:
+ uacpi_shareable_unref_and_delete_if_last(obj->package,
+ free_package);
+ break;
+ case UACPI_OBJECT_FIELD_UNIT:
+ uacpi_shareable_unref_and_delete_if_last(obj->field_unit,
+ free_field_unit);
+ break;
+ case UACPI_OBJECT_MUTEX:
+ uacpi_mutex_unref(obj->mutex);
+ break;
+ case UACPI_OBJECT_EVENT:
+ uacpi_shareable_unref_and_delete_if_last(obj->event,
+ free_event);
+ break;
+ case UACPI_OBJECT_OPERATION_REGION:
+ uacpi_shareable_unref_and_delete_if_last(obj->op_region,
+ free_op_region);
+ break;
+ case UACPI_OBJECT_PROCESSOR:
+ uacpi_shareable_unref_and_delete_if_last(obj->processor,
+ free_processor);
+ break;
+ case UACPI_OBJECT_DEVICE:
+ uacpi_shareable_unref_and_delete_if_last(obj->device,
+ free_device);
+ break;
+ case UACPI_OBJECT_THERMAL_ZONE:
+ uacpi_shareable_unref_and_delete_if_last(obj->thermal_zone,
+ free_thermal_zone);
+ break;
+ default:
+ break;
+ }
+}
+
+static void free_object(uacpi_object *obj)
+{
+ free_object_storage(obj);
+ uacpi_free(obj, sizeof(*obj));
+}
+
+static void make_chain_bugged(uacpi_object *obj)
+{
+ uacpi_warn("object refcount bug, marking chain @%p as bugged\n", obj);
+
+ while (obj) {
+ uacpi_make_shareable_bugged(obj);
+
+ if (obj->type == UACPI_OBJECT_REFERENCE)
+ obj = obj->inner_object;
+ else
+ obj = UACPI_NULL;
+ }
+}
+
+void uacpi_object_ref(uacpi_object *obj)
+{
+ while (obj) {
+ uacpi_shareable_ref(obj);
+
+ if (obj->type == UACPI_OBJECT_REFERENCE)
+ obj = obj->inner_object;
+ else
+ obj = UACPI_NULL;
+ }
+}
+
+static void free_chain(uacpi_object *obj)
+{
+ uacpi_object *next_obj = UACPI_NULL;
+
+ while (obj) {
+ if (obj->type == UACPI_OBJECT_REFERENCE)
+ next_obj = obj->inner_object;
+
+ if (uacpi_shareable_refcount(obj) == 0)
+ free_object(obj);
+
+ obj = next_obj;
+ next_obj = UACPI_NULL;
+ }
+}
+
+void uacpi_object_unref(uacpi_object *obj)
+{
+ uacpi_object *this_obj = obj;
+
+ if (!obj)
+ return;
+
+ while (obj) {
+ if (uacpi_unlikely(uacpi_bugged_shareable(obj)))
+ return;
+
+ uacpi_shareable_unref(obj);
+
+ if (obj->type == UACPI_OBJECT_REFERENCE) {
+ obj = obj->inner_object;
+ } else {
+ obj = UACPI_NULL;
+ }
+ }
+
+ if (uacpi_shareable_refcount(this_obj) == 0)
+ free_chain(this_obj);
+}
+
+static uacpi_status buffer_alloc_and_store(
+ uacpi_object *obj, uacpi_size buf_size,
+ const void *src, uacpi_size src_size
+)
+{
+ if (uacpi_unlikely(!buffer_alloc(obj, buf_size)))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ uacpi_memcpy_zerout(obj->buffer->data, src, buf_size, src_size);
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status assign_buffer(uacpi_object *dst, uacpi_object *src,
+ enum uacpi_assign_behavior behavior)
+{
+ if (behavior == UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY) {
+ dst->buffer = src->buffer;
+ uacpi_shareable_ref(dst->buffer);
+ return UACPI_STATUS_OK;
+ }
+
+ return buffer_alloc_and_store(dst, src->buffer->size,
+ src->buffer->data, src->buffer->size);
+}
+
+struct pkg_copy_req {
+ uacpi_object *dst;
+ uacpi_package *src;
+};
+
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE(pkg_copy_reqs, struct pkg_copy_req, 2)
+DYNAMIC_ARRAY_WITH_INLINE_STORAGE_IMPL(
+ pkg_copy_reqs, struct pkg_copy_req, static
+)
+
+static uacpi_bool pkg_copy_reqs_push(
+ struct pkg_copy_reqs *reqs,
+ uacpi_object *dst, uacpi_package *pkg
+)
+{
+ struct pkg_copy_req *req;
+
+ req = pkg_copy_reqs_alloc(reqs);
+ if (uacpi_unlikely(req == UACPI_NULL))
+ return UACPI_FALSE;
+
+ req->dst = dst;
+ req->src = pkg;
+
+ return UACPI_TRUE;
+}
+
+static uacpi_status deep_copy_package_no_recurse(
+ uacpi_object *dst, uacpi_package *src,
+ struct pkg_copy_reqs *reqs
+)
+{
+ uacpi_size i;
+ uacpi_package *dst_package;
+
+ if (uacpi_unlikely(!package_alloc(dst, src->count,
+ UACPI_PREALLOC_OBJECTS_YES)))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ dst->type = UACPI_OBJECT_PACKAGE;
+ dst_package = dst->package;
+
+ for (i = 0; i < src->count; ++i) {
+ uacpi_status st;
+ uacpi_object *src_obj = src->objects[i];
+ uacpi_object *dst_obj = dst_package->objects[i];
+
+ // Don't copy the internal package index reference
+ if (src_obj->type == UACPI_OBJECT_REFERENCE &&
+ src_obj->flags == UACPI_REFERENCE_KIND_PKG_INDEX)
+ src_obj = src_obj->inner_object;
+
+ if (src_obj->type == UACPI_OBJECT_PACKAGE) {
+ uacpi_bool ret;
+
+ ret = pkg_copy_reqs_push(reqs, dst_obj, src_obj->package);
+ if (uacpi_unlikely(!ret))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ continue;
+ }
+
+ st = uacpi_object_assign(dst_obj, src_obj,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+ if (uacpi_unlikely_error(st))
+ return st;
+ }
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status deep_copy_package(uacpi_object *dst, uacpi_object *src)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ struct pkg_copy_reqs reqs = { 0 };
+
+ pkg_copy_reqs_push(&reqs, dst, src->package);
+
+ while (pkg_copy_reqs_size(&reqs) != 0) {
+ struct pkg_copy_req req;
+
+ req = *pkg_copy_reqs_last(&reqs);
+ pkg_copy_reqs_pop(&reqs);
+
+ ret = deep_copy_package_no_recurse(req.dst, req.src, &reqs);
+ if (uacpi_unlikely_error(ret))
+ break;
+ }
+
+ pkg_copy_reqs_clear(&reqs);
+ return ret;
+}
+
+static uacpi_status assign_mutex(uacpi_object *dst, uacpi_object *src,
+ enum uacpi_assign_behavior behavior)
+{
+ if (behavior == UACPI_ASSIGN_BEHAVIOR_DEEP_COPY) {
+ if (uacpi_likely(mutex_alloc(dst))) {
+ dst->mutex->sync_level = src->mutex->sync_level;
+ return UACPI_STATUS_OK;
+ }
+
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ dst->mutex = src->mutex;
+ uacpi_shareable_ref(dst->mutex);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status assign_event(uacpi_object *dst, uacpi_object *src,
+ enum uacpi_assign_behavior behavior)
+{
+ if (behavior == UACPI_ASSIGN_BEHAVIOR_DEEP_COPY) {
+ if (uacpi_likely(event_alloc(dst)))
+ return UACPI_STATUS_OK;
+
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+
+ dst->event = src->event;
+ uacpi_shareable_ref(dst->event);
+
+ return UACPI_STATUS_OK;
+}
+
+static uacpi_status assign_package(uacpi_object *dst, uacpi_object *src,
+ enum uacpi_assign_behavior behavior)
+{
+ if (behavior == UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY) {
+ dst->package = src->package;
+ uacpi_shareable_ref(dst->package);
+ return UACPI_STATUS_OK;
+ }
+
+ return deep_copy_package(dst, src);
+}
+
+void uacpi_object_attach_child(uacpi_object *parent, uacpi_object *child)
+{
+ uacpi_u32 refs_to_add;
+
+ parent->inner_object = child;
+
+ if (uacpi_unlikely(uacpi_bugged_shareable(parent))) {
+ make_chain_bugged(child);
+ return;
+ }
+
+ refs_to_add = uacpi_shareable_refcount(parent);
+ while (refs_to_add--)
+ uacpi_object_ref(child);
+}
+
+void uacpi_object_detach_child(uacpi_object *parent)
+{
+ uacpi_u32 refs_to_remove;
+ uacpi_object *child;
+
+ child = parent->inner_object;
+ parent->inner_object = UACPI_NULL;
+
+ if (uacpi_unlikely(uacpi_bugged_shareable(parent)))
+ return;
+
+ refs_to_remove = uacpi_shareable_refcount(parent);
+ while (refs_to_remove--)
+ uacpi_object_unref(child);
+}
+
+uacpi_object_type uacpi_object_get_type(uacpi_object *obj)
+{
+ return obj->type;
+}
+
+uacpi_object_type_bits uacpi_object_get_type_bit(uacpi_object *obj)
+{
+ return (1u << obj->type);
+}
+
+uacpi_bool uacpi_object_is(uacpi_object *obj, uacpi_object_type type)
+{
+ return obj->type == type;
+}
+
+uacpi_bool uacpi_object_is_one_of(
+ uacpi_object *obj, uacpi_object_type_bits type_mask
+)
+{
+ return (uacpi_object_get_type_bit(obj) & type_mask) != 0;
+}
+
+#define TYPE_CHECK_USER_OBJ_RET(obj, type_bits, ret) \
+ do { \
+ if (uacpi_unlikely(obj == UACPI_NULL || \
+ !uacpi_object_is_one_of(obj, type_bits))) \
+ return ret; \
+ } while (0)
+
+#define TYPE_CHECK_USER_OBJ(obj, type_bits) \
+ TYPE_CHECK_USER_OBJ_RET(obj, type_bits, UACPI_STATUS_INVALID_ARGUMENT)
+
+#define ENSURE_VALID_USER_OBJ_RET(obj, ret) \
+ do { \
+ if (uacpi_unlikely(obj == UACPI_NULL)) \
+ return ret; \
+ } while (0)
+
+#define ENSURE_VALID_USER_OBJ(obj) \
+ ENSURE_VALID_USER_OBJ_RET(obj, UACPI_STATUS_INVALID_ARGUMENT)
+
+uacpi_status uacpi_object_get_integer(uacpi_object *obj, uacpi_u64 *out)
+{
+ TYPE_CHECK_USER_OBJ(obj, UACPI_OBJECT_INTEGER_BIT);
+
+ *out = obj->integer;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_assign_integer(uacpi_object *obj, uacpi_u64 value)
+{
+ uacpi_object object = { 0 };
+
+ ENSURE_VALID_USER_OBJ(obj);
+
+ object.type = UACPI_OBJECT_INTEGER;
+ object.integer = value;
+
+ return uacpi_object_assign(obj, &object, UACPI_ASSIGN_BEHAVIOR_DEEP_COPY);
+}
+
+void uacpi_buffer_to_view(uacpi_buffer *buf, uacpi_data_view *out_view)
+{
+ out_view->bytes = buf->byte_data;
+ out_view->length = buf->size;
+}
+
+static uacpi_status uacpi_object_do_get_string_or_buffer(
+ uacpi_object *obj, uacpi_data_view *out, uacpi_u32 mask
+)
+{
+ TYPE_CHECK_USER_OBJ(obj, mask);
+
+ uacpi_buffer_to_view(obj->buffer, out);
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_get_string_or_buffer(
+ uacpi_object *obj, uacpi_data_view *out
+)
+{
+ return uacpi_object_do_get_string_or_buffer(
+ obj, out, UACPI_OBJECT_STRING_BIT | UACPI_OBJECT_BUFFER_BIT
+ );
+}
+
+uacpi_status uacpi_object_get_string(uacpi_object *obj, uacpi_data_view *out)
+{
+ return uacpi_object_do_get_string_or_buffer(
+ obj, out, UACPI_OBJECT_STRING_BIT
+ );
+}
+
+uacpi_status uacpi_object_get_buffer(uacpi_object *obj, uacpi_data_view *out)
+{
+ return uacpi_object_do_get_string_or_buffer(
+ obj, out, UACPI_OBJECT_BUFFER_BIT
+ );
+}
+
+uacpi_bool uacpi_object_is_aml_namepath(uacpi_object *obj)
+{
+ TYPE_CHECK_USER_OBJ_RET(obj, UACPI_OBJECT_STRING_BIT, UACPI_FALSE);
+ return obj->flags == UACPI_STRING_KIND_PATH;
+}
+
+uacpi_status uacpi_object_resolve_as_aml_namepath(
+ uacpi_object *obj, uacpi_namespace_node *scope,
+ uacpi_namespace_node **out_node
+)
+{
+ uacpi_status ret;
+ uacpi_namespace_node *node;
+
+ if (!uacpi_object_is_aml_namepath(obj))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_namespace_node_resolve_from_aml_namepath(
+ scope, obj->buffer->text, &node
+ );
+ if (uacpi_likely_success(ret))
+ *out_node = node;
+ return ret;
+}
+
+static uacpi_status uacpi_object_do_assign_buffer(
+ uacpi_object *obj, uacpi_data_view in, uacpi_object_type type
+)
+{
+ uacpi_status ret;
+ uacpi_object tmp_obj = { 0 };
+ uacpi_size dst_buf_size = in.length;
+
+ tmp_obj.type = type;
+
+ ENSURE_VALID_USER_OBJ(obj);
+
+ if (type == UACPI_OBJECT_STRING && (in.length == 0 ||
+ in.const_bytes[in.length - 1] != 0x00))
+ dst_buf_size++;
+
+ ret = buffer_alloc_and_store(
+ &tmp_obj, dst_buf_size, in.const_bytes, in.length
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ ret = uacpi_object_assign(
+ obj, &tmp_obj, UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY
+ );
+ uacpi_shareable_unref_and_delete_if_last(tmp_obj.buffer, free_buffer);
+
+ return ret;
+}
+
+uacpi_status uacpi_object_assign_string(uacpi_object *obj, uacpi_data_view in)
+{
+ return uacpi_object_do_assign_buffer(obj, in, UACPI_OBJECT_STRING);
+}
+
+uacpi_status uacpi_object_assign_buffer(uacpi_object *obj, uacpi_data_view in)
+{
+ return uacpi_object_do_assign_buffer(obj, in, UACPI_OBJECT_BUFFER);
+}
+
+uacpi_object *uacpi_object_create_uninitialized(void)
+{
+ return uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+}
+
+uacpi_status uacpi_object_create_integer_safe(
+ uacpi_u64 value, uacpi_overflow_behavior behavior, uacpi_object **out_obj
+)
+{
+ uacpi_status ret;
+ uacpi_u8 bitness;
+ uacpi_object *obj;
+
+ ret = uacpi_get_aml_bitness(&bitness);
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ switch (behavior) {
+ case UACPI_OVERFLOW_TRUNCATE:
+ case UACPI_OVERFLOW_DISALLOW:
+ if (bitness == 32 && value > 0xFFFFFFFF) {
+ if (behavior == UACPI_OVERFLOW_DISALLOW)
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ value &= 0xFFFFFFFF;
+ }
+ UACPI_FALLTHROUGH;
+ case UACPI_OVERFLOW_ALLOW:
+ obj = uacpi_object_create_integer(value);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ *out_obj = obj;
+ return ret;
+ default:
+ return UACPI_STATUS_INVALID_ARGUMENT;
+ }
+}
+
+uacpi_object *uacpi_object_create_integer(uacpi_u64 value)
+{
+ uacpi_object *obj;
+
+ obj = uacpi_create_object(UACPI_OBJECT_INTEGER);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ obj->integer = value;
+ return obj;
+}
+
+static uacpi_object *uacpi_object_do_create_string_or_buffer(
+ uacpi_data_view view, uacpi_object_type type
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+
+ obj = uacpi_create_object(UACPI_OBJECT_UNINITIALIZED);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_NULL;
+
+ ret = uacpi_object_do_assign_buffer(obj, view, type);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_object_unref(obj);
+ return UACPI_NULL;
+ }
+
+ return obj;
+}
+
+uacpi_object *uacpi_object_create_string(uacpi_data_view view)
+{
+ return uacpi_object_do_create_string_or_buffer(view, UACPI_OBJECT_STRING);
+}
+
+uacpi_object *uacpi_object_create_buffer(uacpi_data_view view)
+{
+ return uacpi_object_do_create_string_or_buffer(view, UACPI_OBJECT_BUFFER);
+}
+
+uacpi_object *uacpi_object_create_cstring(const uacpi_char *str)
+{
+ uacpi_data_view data_view = { 0 };
+
+ data_view.const_text = str;
+ data_view.length = uacpi_strlen(str) + 1;
+ return uacpi_object_create_string(data_view);
+}
+
+uacpi_status uacpi_object_get_package(
+ uacpi_object *obj, uacpi_object_array *out
+)
+{
+ TYPE_CHECK_USER_OBJ(obj, UACPI_OBJECT_PACKAGE_BIT);
+
+ out->objects = obj->package->objects;
+ out->count = obj->package->count;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_object *uacpi_object_create_reference(uacpi_object *child)
+{
+ uacpi_object *obj;
+
+ ENSURE_VALID_USER_OBJ_RET(child, UACPI_NULL);
+
+ obj = uacpi_create_object(UACPI_OBJECT_REFERENCE);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_NULL;
+
+ uacpi_object_attach_child(obj, child);
+ obj->flags = UACPI_REFERENCE_KIND_ARG;
+
+ return obj;
+}
+
+uacpi_status uacpi_object_assign_reference(
+ uacpi_object *obj, uacpi_object *child
+)
+{
+ uacpi_status ret;
+ uacpi_object object = { 0 };
+
+ ENSURE_VALID_USER_OBJ(obj);
+ ENSURE_VALID_USER_OBJ(child);
+
+ // First clear out the object
+ object.type = UACPI_OBJECT_UNINITIALIZED;
+ ret = uacpi_object_assign(
+ obj, &object,
+ UACPI_ASSIGN_BEHAVIOR_DEEP_COPY
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ obj->type = UACPI_OBJECT_REFERENCE;
+ uacpi_object_attach_child(obj, child);
+ obj->flags = UACPI_REFERENCE_KIND_ARG;
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_get_dereferenced(
+ uacpi_object *obj, uacpi_object **out
+)
+{
+ TYPE_CHECK_USER_OBJ(obj, UACPI_OBJECT_REFERENCE_BIT);
+
+ *out = obj->inner_object;
+ uacpi_shareable_ref(*out);
+
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_get_processor_info(
+ uacpi_object *obj, uacpi_processor_info *out
+)
+{
+ TYPE_CHECK_USER_OBJ(obj, UACPI_OBJECT_PROCESSOR_BIT);
+
+ out->id = obj->processor->id;
+ out->block_address = obj->processor->block_address;
+ out->block_length = obj->processor->block_length;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_get_power_resource_info(
+ uacpi_object *obj, uacpi_power_resource_info *out
+)
+{
+ TYPE_CHECK_USER_OBJ(obj, UACPI_OBJECT_POWER_RESOURCE_BIT);
+
+ out->system_level = obj->power_resource.system_level;
+ out->resource_order = obj->power_resource.resource_order;
+ return UACPI_STATUS_OK;
+}
+
+uacpi_status uacpi_object_assign_package(
+ uacpi_object *obj, uacpi_object_array in
+)
+{
+ uacpi_status ret;
+ uacpi_size i;
+ uacpi_object tmp_obj = {
+ .type = UACPI_OBJECT_PACKAGE,
+ };
+
+ ENSURE_VALID_USER_OBJ(obj);
+
+ if (uacpi_unlikely(!package_alloc(&tmp_obj, in.count,
+ UACPI_PREALLOC_OBJECTS_NO)))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ obj->type = UACPI_OBJECT_PACKAGE;
+
+ for (i = 0; i < in.count; ++i) {
+ tmp_obj.package->objects[i] = in.objects[i];
+ uacpi_object_ref(tmp_obj.package->objects[i]);
+ }
+
+ ret = uacpi_object_assign(obj, &tmp_obj, UACPI_ASSIGN_BEHAVIOR_SHALLOW_COPY);
+ uacpi_shareable_unref_and_delete_if_last(tmp_obj.package, free_package);
+
+ return ret;
+}
+
+uacpi_object *uacpi_object_create_package(uacpi_object_array in)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+
+ obj = uacpi_object_create_uninitialized();
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return obj;
+
+ ret = uacpi_object_assign_package(obj, in);
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_object_unref(obj);
+ return UACPI_NULL;
+ }
+
+ return obj;
+}
+
+uacpi_status uacpi_object_assign(uacpi_object *dst, uacpi_object *src,
+ enum uacpi_assign_behavior behavior)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+
+ if (src == dst)
+ return ret;
+
+ switch (dst->type) {
+ case UACPI_OBJECT_REFERENCE:
+ uacpi_object_detach_child(dst);
+ break;
+ case UACPI_OBJECT_STRING:
+ case UACPI_OBJECT_BUFFER:
+ case UACPI_OBJECT_METHOD:
+ case UACPI_OBJECT_PACKAGE:
+ case UACPI_OBJECT_MUTEX:
+ case UACPI_OBJECT_EVENT:
+ case UACPI_OBJECT_PROCESSOR:
+ case UACPI_OBJECT_DEVICE:
+ case UACPI_OBJECT_THERMAL_ZONE:
+ free_object_storage(dst);
+ break;
+ default:
+ break;
+ }
+
+ switch (src->type) {
+ case UACPI_OBJECT_UNINITIALIZED:
+ case UACPI_OBJECT_DEBUG:
+ break;
+ case UACPI_OBJECT_BUFFER:
+ case UACPI_OBJECT_STRING:
+ dst->flags = src->flags;
+ ret = assign_buffer(dst, src, behavior);
+ break;
+ case UACPI_OBJECT_BUFFER_FIELD:
+ dst->buffer_field = src->buffer_field;
+ uacpi_shareable_ref(dst->buffer_field.backing);
+ break;
+ case UACPI_OBJECT_BUFFER_INDEX:
+ dst->buffer_index = src->buffer_index;
+ uacpi_shareable_ref(dst->buffer_index.buffer);
+ break;
+ case UACPI_OBJECT_INTEGER:
+ dst->integer = src->integer;
+ break;
+ case UACPI_OBJECT_METHOD:
+ dst->method = src->method;
+ uacpi_shareable_ref(dst->method);
+ break;
+ case UACPI_OBJECT_MUTEX:
+ ret = assign_mutex(dst, src, behavior);
+ break;
+ case UACPI_OBJECT_EVENT:
+ ret = assign_event(dst, src, behavior);
+ break;
+ case UACPI_OBJECT_OPERATION_REGION:
+ dst->op_region = src->op_region;
+ uacpi_shareable_ref(dst->op_region);
+ break;
+ case UACPI_OBJECT_PACKAGE:
+ ret = assign_package(dst, src, behavior);
+ break;
+ case UACPI_OBJECT_FIELD_UNIT:
+ dst->field_unit = src->field_unit;
+ uacpi_shareable_ref(dst->field_unit);
+ break;
+ case UACPI_OBJECT_REFERENCE:
+ uacpi_object_attach_child(dst, src->inner_object);
+ break;
+ case UACPI_OBJECT_PROCESSOR:
+ dst->processor = src->processor;
+ uacpi_shareable_ref(dst->processor);
+ break;
+ case UACPI_OBJECT_DEVICE:
+ dst->device = src->device;
+ uacpi_shareable_ref(dst->device);
+ break;
+ case UACPI_OBJECT_THERMAL_ZONE:
+ dst->thermal_zone = src->thermal_zone;
+ uacpi_shareable_ref(dst->thermal_zone);
+ break;
+ default:
+ ret = UACPI_STATUS_UNIMPLEMENTED;
+ }
+
+ if (ret == UACPI_STATUS_OK)
+ dst->type = src->type;
+
+ return ret;
+}
+
+struct uacpi_object *uacpi_create_internal_reference(
+ enum uacpi_reference_kind kind, uacpi_object *child
+)
+{
+ uacpi_object *ret;
+
+ ret = uacpi_create_object(UACPI_OBJECT_REFERENCE);
+ if (uacpi_unlikely(ret == UACPI_NULL))
+ return ret;
+
+ ret->flags = kind;
+ uacpi_object_attach_child(ret, child);
+ return ret;
+}
+
+uacpi_object *uacpi_unwrap_internal_reference(uacpi_object *object)
+{
+ for (;;) {
+ if (object->type != UACPI_OBJECT_REFERENCE ||
+ (object->flags == UACPI_REFERENCE_KIND_REFOF ||
+ object->flags == UACPI_REFERENCE_KIND_PKG_INDEX))
+ return object;
+
+ object = object->inner_object;
+ }
+}
+
+#endif // !UACPI_BAREBONES_MODE
diff --git a/sys/dev/acpi/uacpi/uacpi.c b/sys/dev/acpi/uacpi/uacpi.c
new file mode 100644
index 0000000..c6c569f
--- /dev/null
+++ b/sys/dev/acpi/uacpi/uacpi.c
@@ -0,0 +1,998 @@
+#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)
+{
+ static uacpi_bool version_printed = UACPI_FALSE;
+
+ if (g_uacpi_rt_ctx.log_level == 0)
+ uacpi_context_set_log_level(UACPI_DEFAULT_LOG_LEVEL);
+
+ 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
diff --git a/sys/dev/acpi/uacpi/utilities.c b/sys/dev/acpi/uacpi/utilities.c
new file mode 100644
index 0000000..c7ca20a
--- /dev/null
+++ b/sys/dev/acpi/uacpi/utilities.c
@@ -0,0 +1,1156 @@
+#include <uacpi/types.h>
+#include <uacpi/status.h>
+#include <uacpi/uacpi.h>
+
+#include <uacpi/internal/context.h>
+#include <uacpi/internal/utilities.h>
+#include <uacpi/internal/log.h>
+#include <uacpi/internal/namespace.h>
+
+enum char_type {
+ CHAR_TYPE_CONTROL = 1 << 0,
+ CHAR_TYPE_SPACE = 1 << 1,
+ CHAR_TYPE_BLANK = 1 << 2,
+ CHAR_TYPE_PUNCTUATION = 1 << 3,
+ CHAR_TYPE_LOWER = 1 << 4,
+ CHAR_TYPE_UPPER = 1 << 5,
+ CHAR_TYPE_DIGIT = 1 << 6,
+ CHAR_TYPE_HEX_DIGIT = 1 << 7,
+ CHAR_TYPE_ALPHA = CHAR_TYPE_LOWER | CHAR_TYPE_UPPER,
+ CHAR_TYPE_ALHEX = CHAR_TYPE_ALPHA | CHAR_TYPE_HEX_DIGIT,
+ CHAR_TYPE_ALNUM = CHAR_TYPE_ALPHA | CHAR_TYPE_DIGIT,
+};
+
+static const uacpi_u8 ascii_map[256] = {
+ CHAR_TYPE_CONTROL, // 0
+ CHAR_TYPE_CONTROL, // 1
+ CHAR_TYPE_CONTROL, // 2
+ CHAR_TYPE_CONTROL, // 3
+ CHAR_TYPE_CONTROL, // 4
+ CHAR_TYPE_CONTROL, // 5
+ CHAR_TYPE_CONTROL, // 6
+ CHAR_TYPE_CONTROL, // 7
+ CHAR_TYPE_CONTROL, // -> 8 control codes
+
+ CHAR_TYPE_CONTROL | CHAR_TYPE_SPACE | CHAR_TYPE_BLANK, // 9 tab
+
+ CHAR_TYPE_CONTROL | CHAR_TYPE_SPACE, // 10
+ CHAR_TYPE_CONTROL | CHAR_TYPE_SPACE, // 11
+ CHAR_TYPE_CONTROL | CHAR_TYPE_SPACE, // 12
+ CHAR_TYPE_CONTROL | CHAR_TYPE_SPACE, // -> 13 whitespaces
+
+ CHAR_TYPE_CONTROL, // 14
+ CHAR_TYPE_CONTROL, // 15
+ CHAR_TYPE_CONTROL, // 16
+ CHAR_TYPE_CONTROL, // 17
+ CHAR_TYPE_CONTROL, // 18
+ CHAR_TYPE_CONTROL, // 19
+ CHAR_TYPE_CONTROL, // 20
+ CHAR_TYPE_CONTROL, // 21
+ CHAR_TYPE_CONTROL, // 22
+ CHAR_TYPE_CONTROL, // 23
+ CHAR_TYPE_CONTROL, // 24
+ CHAR_TYPE_CONTROL, // 25
+ CHAR_TYPE_CONTROL, // 26
+ CHAR_TYPE_CONTROL, // 27
+ CHAR_TYPE_CONTROL, // 28
+ CHAR_TYPE_CONTROL, // 29
+ CHAR_TYPE_CONTROL, // 30
+ CHAR_TYPE_CONTROL, // -> 31 control codes
+
+ CHAR_TYPE_SPACE | CHAR_TYPE_BLANK, // 32 space
+
+ CHAR_TYPE_PUNCTUATION, // 33
+ CHAR_TYPE_PUNCTUATION, // 34
+ CHAR_TYPE_PUNCTUATION, // 35
+ CHAR_TYPE_PUNCTUATION, // 36
+ CHAR_TYPE_PUNCTUATION, // 37
+ CHAR_TYPE_PUNCTUATION, // 38
+ CHAR_TYPE_PUNCTUATION, // 39
+ CHAR_TYPE_PUNCTUATION, // 40
+ CHAR_TYPE_PUNCTUATION, // 41
+ CHAR_TYPE_PUNCTUATION, // 42
+ CHAR_TYPE_PUNCTUATION, // 43
+ CHAR_TYPE_PUNCTUATION, // 44
+ CHAR_TYPE_PUNCTUATION, // 45
+ CHAR_TYPE_PUNCTUATION, // 46
+ CHAR_TYPE_PUNCTUATION, // -> 47 punctuation
+
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 48
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 49
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 50
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 51
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 52
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 53
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 54
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 55
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // 56
+ CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT, // -> 57 digits
+
+ CHAR_TYPE_PUNCTUATION, // 58
+ CHAR_TYPE_PUNCTUATION, // 59
+ CHAR_TYPE_PUNCTUATION, // 60
+ CHAR_TYPE_PUNCTUATION, // 61
+ CHAR_TYPE_PUNCTUATION, // 62
+ CHAR_TYPE_PUNCTUATION, // 63
+ CHAR_TYPE_PUNCTUATION, // -> 64 punctuation
+
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // 65
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // 66
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // 67
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // 68
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // 69
+ CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT, // -> 70 ABCDEF
+
+ CHAR_TYPE_UPPER, // 71
+ CHAR_TYPE_UPPER, // 72
+ CHAR_TYPE_UPPER, // 73
+ CHAR_TYPE_UPPER, // 74
+ CHAR_TYPE_UPPER, // 75
+ CHAR_TYPE_UPPER, // 76
+ CHAR_TYPE_UPPER, // 77
+ CHAR_TYPE_UPPER, // 78
+ CHAR_TYPE_UPPER, // 79
+ CHAR_TYPE_UPPER, // 80
+ CHAR_TYPE_UPPER, // 81
+ CHAR_TYPE_UPPER, // 82
+ CHAR_TYPE_UPPER, // 83
+ CHAR_TYPE_UPPER, // 84
+ CHAR_TYPE_UPPER, // 85
+ CHAR_TYPE_UPPER, // 86
+ CHAR_TYPE_UPPER, // 87
+ CHAR_TYPE_UPPER, // 88
+ CHAR_TYPE_UPPER, // 89
+ CHAR_TYPE_UPPER, // -> 90 the rest of UPPERCASE alphabet
+
+ CHAR_TYPE_PUNCTUATION, // 91
+ CHAR_TYPE_PUNCTUATION, // 92
+ CHAR_TYPE_PUNCTUATION, // 93
+ CHAR_TYPE_PUNCTUATION, // 94
+ CHAR_TYPE_PUNCTUATION, // 95
+ CHAR_TYPE_PUNCTUATION, // -> 96 punctuation
+
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // 97
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // 98
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // 99
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // 100
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // 101
+ CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT, // -> 102 abcdef
+
+ CHAR_TYPE_LOWER, // 103
+ CHAR_TYPE_LOWER, // 104
+ CHAR_TYPE_LOWER, // 105
+ CHAR_TYPE_LOWER, // 106
+ CHAR_TYPE_LOWER, // 107
+ CHAR_TYPE_LOWER, // 108
+ CHAR_TYPE_LOWER, // 109
+ CHAR_TYPE_LOWER, // 110
+ CHAR_TYPE_LOWER, // 111
+ CHAR_TYPE_LOWER, // 112
+ CHAR_TYPE_LOWER, // 113
+ CHAR_TYPE_LOWER, // 114
+ CHAR_TYPE_LOWER, // 115
+ CHAR_TYPE_LOWER, // 116
+ CHAR_TYPE_LOWER, // 117
+ CHAR_TYPE_LOWER, // 118
+ CHAR_TYPE_LOWER, // 119
+ CHAR_TYPE_LOWER, // 120
+ CHAR_TYPE_LOWER, // 121
+ CHAR_TYPE_LOWER, // -> 122 the rest of UPPERCASE alphabet
+
+ CHAR_TYPE_PUNCTUATION, // 123
+ CHAR_TYPE_PUNCTUATION, // 124
+ CHAR_TYPE_PUNCTUATION, // 125
+ CHAR_TYPE_PUNCTUATION, // -> 126 punctuation
+
+ CHAR_TYPE_CONTROL // 127 backspace
+};
+
+static uacpi_bool is_char(uacpi_char c, enum char_type type)
+{
+ return (ascii_map[(uacpi_u8)c] & type) == type;
+}
+
+static uacpi_char to_lower(uacpi_char c)
+{
+ if (is_char(c, CHAR_TYPE_UPPER))
+ return c + ('a' - 'A');
+
+ return c;
+}
+
+static uacpi_bool peek_one(
+ const uacpi_char **str, const uacpi_size *size, uacpi_char *out_char
+)
+{
+ if (*size == 0)
+ return UACPI_FALSE;
+
+ *out_char = **str;
+ return UACPI_TRUE;
+}
+
+static uacpi_bool consume_one(
+ const uacpi_char **str, uacpi_size *size, uacpi_char *out_char
+)
+{
+ if (!peek_one(str, size, out_char))
+ return UACPI_FALSE;
+
+ *str += 1;
+ *size -= 1;
+ return UACPI_TRUE;
+}
+
+static uacpi_bool consume_if(
+ const uacpi_char **str, uacpi_size *size, enum char_type type
+)
+{
+ uacpi_char c;
+
+ if (!peek_one(str, size, &c) || !is_char(c, type))
+ return UACPI_FALSE;
+
+ *str += 1;
+ *size -= 1;
+ return UACPI_TRUE;
+}
+
+static uacpi_bool consume_if_equals(
+ const uacpi_char **str, uacpi_size *size, uacpi_char c
+)
+{
+ uacpi_char c1;
+
+ if (!peek_one(str, size, &c1) || to_lower(c1) != c)
+ return UACPI_FALSE;
+
+ *str += 1;
+ *size -= 1;
+ return UACPI_TRUE;
+}
+
+uacpi_status uacpi_string_to_integer(
+ const uacpi_char *str, uacpi_size max_chars, enum uacpi_base base,
+ uacpi_u64 *out_value
+)
+{
+ uacpi_status ret = UACPI_STATUS_INVALID_ARGUMENT;
+ uacpi_bool negative = UACPI_FALSE;
+ uacpi_u64 next, value = 0;
+ uacpi_char c = '\0';
+
+ while (consume_if(&str, &max_chars, CHAR_TYPE_SPACE));
+
+ if (consume_if_equals(&str, &max_chars, '-'))
+ negative = UACPI_TRUE;
+ else
+ consume_if_equals(&str, &max_chars, '+');
+
+ if (base == UACPI_BASE_AUTO) {
+ base = UACPI_BASE_DEC;
+
+ if (consume_if_equals(&str, &max_chars, '0')) {
+ base = UACPI_BASE_OCT;
+ if (consume_if_equals(&str, &max_chars, 'x'))
+ base = UACPI_BASE_HEX;
+ }
+ }
+
+ while (consume_one(&str, &max_chars, &c)) {
+ switch (ascii_map[(uacpi_u8)c] & (CHAR_TYPE_DIGIT | CHAR_TYPE_ALHEX)) {
+ case CHAR_TYPE_DIGIT | CHAR_TYPE_HEX_DIGIT:
+ next = c - '0';
+ if (base == UACPI_BASE_OCT && next > 7)
+ goto out;
+ break;
+ case CHAR_TYPE_LOWER | CHAR_TYPE_HEX_DIGIT:
+ case CHAR_TYPE_UPPER | CHAR_TYPE_HEX_DIGIT:
+ if (base != UACPI_BASE_HEX)
+ goto out;
+ next = 10 + (to_lower(c) - 'a');
+ break;
+ default:
+ goto out;
+ }
+
+ next = (value * base) + next;
+ if ((next / base) != value) {
+ value = 0xFFFFFFFFFFFFFFFF;
+ goto out;
+ }
+
+ value = next;
+ }
+
+out:
+ if (negative)
+ value = -((uacpi_i64)value);
+
+ *out_value = value;
+ if (max_chars == 0 || c == '\0')
+ ret = UACPI_STATUS_OK;
+
+ return ret;
+}
+
+#ifndef UACPI_BAREBONES_MODE
+
+static inline uacpi_bool is_valid_name_byte(uacpi_u8 c)
+{
+ // ‘_’ := 0x5F
+ if (c == 0x5F)
+ return UACPI_TRUE;
+
+ /*
+ * LeadNameChar := ‘A’-‘Z’ | ‘_’
+ * DigitChar := ‘0’ - ‘9’
+ * NameChar := DigitChar | LeadNameChar
+ * ‘A’-‘Z’ := 0x41 - 0x5A
+ * ‘0’-‘9’ := 0x30 - 0x39
+ */
+ return (ascii_map[c] & (CHAR_TYPE_DIGIT | CHAR_TYPE_UPPER)) != 0;
+}
+
+uacpi_bool uacpi_is_valid_nameseg(uacpi_u8 *nameseg)
+{
+ return is_valid_name_byte(nameseg[0]) &&
+ is_valid_name_byte(nameseg[1]) &&
+ is_valid_name_byte(nameseg[2]) &&
+ is_valid_name_byte(nameseg[3]);
+}
+
+void uacpi_eisa_id_to_string(uacpi_u32 id, uacpi_char *out_string)
+{
+ static uacpi_char hex_to_ascii[16] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'A', 'B', 'C', 'D', 'E', 'F'
+ };
+
+ /*
+ * For whatever reason bits are encoded upper to lower here, swap
+ * them around so that we don't have to do ridiculous bit shifts
+ * everywhere.
+ */
+ union {
+ uacpi_u8 bytes[4];
+ uacpi_u32 dword;
+ } orig, swapped;
+
+ orig.dword = id;
+ swapped.bytes[0] = orig.bytes[3];
+ swapped.bytes[1] = orig.bytes[2];
+ swapped.bytes[2] = orig.bytes[1];
+ swapped.bytes[3] = orig.bytes[0];
+
+ /*
+ * Bit 16 - 20: 3rd character (- 0x40) of mfg code
+ * Bit 21 - 25: 2nd character (- 0x40) of mfg code
+ * Bit 26 - 30: 1st character (- 0x40) of mfg code
+ */
+ out_string[0] = (uacpi_char)(0x40 + ((swapped.dword >> 26) & 0x1F));
+ out_string[1] = (uacpi_char)(0x40 + ((swapped.dword >> 21) & 0x1F));
+ out_string[2] = (uacpi_char)(0x40 + ((swapped.dword >> 16) & 0x1F));
+
+ /*
+ * Bit 0 - 3 : 4th hex digit of product number
+ * Bit 4 - 7 : 3rd hex digit of product number
+ * Bit 8 - 11: 2nd hex digit of product number
+ * Bit 12 - 15: 1st hex digit of product number
+ */
+ out_string[3] = hex_to_ascii[(swapped.dword >> 12) & 0x0F];
+ out_string[4] = hex_to_ascii[(swapped.dword >> 8 ) & 0x0F];
+ out_string[5] = hex_to_ascii[(swapped.dword >> 4 ) & 0x0F];
+ out_string[6] = hex_to_ascii[(swapped.dword >> 0 ) & 0x0F];
+
+ out_string[7] = '\0';
+}
+
+#define PNP_ID_LENGTH 8
+
+uacpi_status uacpi_eval_hid(uacpi_namespace_node *node, uacpi_id_string **out_id)
+{
+ uacpi_status ret;
+ uacpi_object *hid_ret;
+ uacpi_id_string *id = UACPI_NULL;
+ uacpi_u32 size;
+
+ ret = uacpi_eval_typed(
+ node, "_HID", UACPI_NULL,
+ UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT,
+ &hid_ret
+ );
+ if (ret != UACPI_STATUS_OK)
+ return ret;
+
+ size = sizeof(uacpi_id_string);
+
+ switch (hid_ret->type) {
+ case UACPI_OBJECT_STRING: {
+ uacpi_buffer *buf = hid_ret->buffer;
+
+ size += buf->size;
+ if (uacpi_unlikely(buf->size == 0 || size < buf->size)) {
+ uacpi_object_name name = uacpi_namespace_node_name(node);
+
+ uacpi_error(
+ "%.4s._HID: empty/invalid EISA ID string (%zu bytes)\n",
+ name.text, buf->size
+ );
+ ret = UACPI_STATUS_AML_BAD_ENCODING;
+ break;
+ }
+
+ id = uacpi_kernel_alloc(size);
+ if (uacpi_unlikely(id == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ break;
+ }
+ id->size = buf->size;
+ id->value = UACPI_PTR_ADD(id, sizeof(uacpi_id_string));
+
+ uacpi_memcpy(id->value, buf->text, buf->size);
+ id->value[buf->size - 1] = '\0';
+ break;
+ }
+
+ case UACPI_OBJECT_INTEGER:
+ size += PNP_ID_LENGTH;
+
+ id = uacpi_kernel_alloc(size);
+ if (uacpi_unlikely(id == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ break;
+ }
+ id->size = PNP_ID_LENGTH;
+ id->value = UACPI_PTR_ADD(id, sizeof(uacpi_id_string));
+
+ uacpi_eisa_id_to_string(hid_ret->integer, id->value);
+ break;
+ }
+
+ uacpi_object_unref(hid_ret);
+ if (uacpi_likely_success(ret))
+ *out_id = id;
+ return ret;
+}
+
+void uacpi_free_id_string(uacpi_id_string *id)
+{
+ if (id == UACPI_NULL)
+ return;
+
+ uacpi_free(id, sizeof(uacpi_id_string) + id->size);
+}
+
+uacpi_status uacpi_eval_cid(
+ uacpi_namespace_node *node, uacpi_pnp_id_list **out_list
+)
+{
+ uacpi_status ret;
+ uacpi_object *object, *cid_ret;
+ uacpi_object **objects;
+ uacpi_size num_ids, i;
+ uacpi_u32 size;
+ uacpi_id_string *id;
+ uacpi_char *id_buffer;
+ uacpi_pnp_id_list *list;
+
+ ret = uacpi_eval_typed(
+ node, "_CID", UACPI_NULL,
+ UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT |
+ UACPI_OBJECT_PACKAGE_BIT,
+ &cid_ret
+ );
+ if (ret != UACPI_STATUS_OK)
+ return ret;
+
+ switch (cid_ret->type) {
+ case UACPI_OBJECT_PACKAGE:
+ objects = cid_ret->package->objects;
+ num_ids = cid_ret->package->count;
+ break;
+ default:
+ objects = &cid_ret;
+ num_ids = 1;
+ break;
+ }
+
+ size = sizeof(uacpi_pnp_id_list);
+ size += num_ids * sizeof(uacpi_id_string);
+
+ for (i = 0; i < num_ids; ++i) {
+ object = objects[i];
+
+ switch (object->type) {
+ case UACPI_OBJECT_STRING: {
+ uacpi_size buf_size = object->buffer->size;
+
+ if (uacpi_unlikely(buf_size == 0)) {
+ uacpi_object_name name = uacpi_namespace_node_name(node);
+
+ uacpi_error(
+ "%.4s._CID: empty EISA ID string (sub-object %zu)\n",
+ name.text, i
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+
+ size += buf_size;
+ if (uacpi_unlikely(size < buf_size)) {
+ uacpi_object_name name = uacpi_namespace_node_name(node);
+
+ uacpi_error(
+ "%.4s._CID: buffer size overflow (+ %zu)\n",
+ name.text, buf_size
+ );
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ break;
+ }
+
+ case UACPI_OBJECT_INTEGER:
+ size += PNP_ID_LENGTH;
+ break;
+ default: {
+ uacpi_object_name name = uacpi_namespace_node_name(node);
+
+ uacpi_error(
+ "%.4s._CID: invalid package sub-object %zu type: %s\n",
+ name.text, i,
+ uacpi_object_type_to_string(object->type)
+ );
+ return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
+ }
+ }
+ }
+
+ list = uacpi_kernel_alloc(size);
+ if (uacpi_unlikely(list == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ list->num_ids = num_ids;
+ list->size = size - sizeof(uacpi_pnp_id_list);
+
+ id_buffer = UACPI_PTR_ADD(list, sizeof(uacpi_pnp_id_list));
+ id_buffer += num_ids * sizeof(uacpi_id_string);
+
+ for (i = 0; i < num_ids; ++i) {
+ object = objects[i];
+ id = &list->ids[i];
+
+ switch (object->type) {
+ case UACPI_OBJECT_STRING: {
+ uacpi_buffer *buf = object->buffer;
+
+ id->size = buf->size;
+ id->value = id_buffer;
+
+ uacpi_memcpy(id->value, buf->text, id->size);
+ id->value[id->size - 1] = '\0';
+ break;
+ }
+
+ case UACPI_OBJECT_INTEGER:
+ id->size = PNP_ID_LENGTH;
+ id->value = id_buffer;
+ uacpi_eisa_id_to_string(object->integer, id_buffer);
+ break;
+ }
+
+ id_buffer += id->size;
+ }
+
+ uacpi_object_unref(cid_ret);
+ *out_list = list;
+ return ret;
+}
+
+void uacpi_free_pnp_id_list(uacpi_pnp_id_list *list)
+{
+ if (list == UACPI_NULL)
+ return;
+
+ uacpi_free(list, sizeof(uacpi_pnp_id_list) + list->size);
+}
+
+uacpi_status uacpi_eval_sta(uacpi_namespace_node *node, uacpi_u32 *flags)
+{
+ uacpi_status ret;
+ uacpi_u64 value = 0;
+
+ ret = uacpi_eval_integer(node, "_STA", UACPI_NULL, &value);
+
+ /*
+ * ACPI 6.5 specification:
+ * If a device object (including the processor object) does not have
+ * an _STA object, then OSPM assumes that all of the above bits are
+ * set (i.e., the device is present, enabled, shown in the UI,
+ * and functioning).
+ */
+ if (ret == UACPI_STATUS_NOT_FOUND) {
+ value = 0xFFFFFFFF;
+ ret = UACPI_STATUS_OK;
+ }
+
+ *flags = value;
+ return ret;
+}
+
+uacpi_status uacpi_eval_adr(uacpi_namespace_node *node, uacpi_u64 *out)
+{
+ return uacpi_eval_integer(node, "_ADR", UACPI_NULL, out);
+}
+
+#define CLS_REPR_SIZE 7
+
+static uacpi_u8 extract_package_byte_or_zero(uacpi_package *pkg, uacpi_size i)
+{
+ uacpi_object *obj;
+
+ if (uacpi_unlikely(pkg->count <= i))
+ return 0;
+
+ obj = pkg->objects[i];
+ if (uacpi_unlikely(obj->type != UACPI_OBJECT_INTEGER))
+ return 0;
+
+ return obj->integer;
+}
+
+uacpi_status uacpi_eval_cls(
+ uacpi_namespace_node *node, uacpi_id_string **out_id
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ uacpi_package *pkg;
+ uacpi_u8 class_codes[3];
+ uacpi_id_string *id_string;
+
+ ret = uacpi_eval_typed(
+ node, "_CLS", UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, &obj
+ );
+ if (ret != UACPI_STATUS_OK)
+ return ret;
+
+ pkg = obj->package;
+ class_codes[0] = extract_package_byte_or_zero(pkg, 0);
+ class_codes[1] = extract_package_byte_or_zero(pkg, 1);
+ class_codes[2] = extract_package_byte_or_zero(pkg, 2);
+
+ id_string = uacpi_kernel_alloc(sizeof(uacpi_id_string) + CLS_REPR_SIZE);
+ if (uacpi_unlikely(id_string == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+
+ id_string->size = CLS_REPR_SIZE;
+ id_string->value = UACPI_PTR_ADD(id_string, sizeof(uacpi_id_string));
+
+ uacpi_snprintf(
+ id_string->value, CLS_REPR_SIZE, "%02X%02X%02X",
+ class_codes[0], class_codes[1], class_codes[2]
+ );
+
+out:
+ if (uacpi_likely_success(ret))
+ *out_id = id_string;
+
+ uacpi_object_unref(obj);
+ return ret;
+}
+
+uacpi_status uacpi_eval_uid(
+ uacpi_namespace_node *node, uacpi_id_string **out_uid
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj;
+ uacpi_id_string *id_string;
+ uacpi_u32 size;
+
+ ret = uacpi_eval_typed(
+ node, "_UID", UACPI_NULL,
+ UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT,
+ &obj
+ );
+ if (ret != UACPI_STATUS_OK)
+ return ret;
+
+ if (obj->type == UACPI_OBJECT_STRING) {
+ size = obj->buffer->size;
+ if (uacpi_unlikely(size == 0 || size > 0xE0000000)) {
+ uacpi_object_name name = uacpi_namespace_node_name(node);
+
+ uacpi_error(
+ "invalid %.4s._UID string size: %u\n",
+ name.text, size
+ );
+ ret = UACPI_STATUS_AML_BAD_ENCODING;
+ goto out;
+ }
+ } else {
+ size = uacpi_snprintf(
+ UACPI_NULL, 0, "%"UACPI_PRIu64, UACPI_FMT64(obj->integer)
+ ) + 1;
+ }
+
+ id_string = uacpi_kernel_alloc(sizeof(uacpi_id_string) + size);
+ if (uacpi_unlikely(id_string == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+
+ id_string->value = UACPI_PTR_ADD(id_string, sizeof(uacpi_id_string));
+ id_string->size = size;
+
+ if (obj->type == UACPI_OBJECT_STRING) {
+ uacpi_memcpy(id_string->value, obj->buffer->text, size);
+ id_string->value[size - 1] = '\0';
+ } else {
+ uacpi_snprintf(
+ id_string->value, id_string->size, "%"UACPI_PRIu64,
+ UACPI_FMT64(obj->integer)
+ );
+ }
+
+out:
+ if (uacpi_likely_success(ret))
+ *out_uid = id_string;
+
+ uacpi_object_unref(obj);
+ return ret;
+}
+
+static uacpi_bool matches_any(
+ uacpi_id_string *id, const uacpi_char *const *ids
+)
+{
+ uacpi_size i;
+
+ for (i = 0; ids[i]; ++i) {
+ if (uacpi_strcmp(id->value, ids[i]) == 0)
+ return UACPI_TRUE;
+ }
+
+ return UACPI_FALSE;
+}
+
+static uacpi_status uacpi_eval_dstate_method_template(
+ uacpi_namespace_node *parent, uacpi_char *template, uacpi_u8 num_methods,
+ uacpi_u8 *out_values
+)
+{
+ uacpi_u8 i;
+ uacpi_status ret = UACPI_STATUS_NOT_FOUND, eval_ret;
+ uacpi_object *obj;
+
+ // We expect either _SxD or _SxW, so increment template[2]
+ for (i = 0; i < num_methods; ++i, template[2]++) {
+ eval_ret = uacpi_eval_typed(
+ parent, template, UACPI_NULL, UACPI_OBJECT_INTEGER_BIT, &obj
+ );
+ if (eval_ret == UACPI_STATUS_OK) {
+ ret = UACPI_STATUS_OK;
+ out_values[i] = obj->integer;
+ uacpi_object_unref(obj);
+ continue;
+ }
+
+ out_values[i] = 0xFF;
+ if (uacpi_unlikely(eval_ret != UACPI_STATUS_NOT_FOUND)) {
+ const char *path;
+
+ path = uacpi_namespace_node_generate_absolute_path(parent);
+ uacpi_warn(
+ "failed to evaluate %s.%s: %s\n",
+ path, template, uacpi_status_to_string(eval_ret)
+ );
+ uacpi_free_dynamic_string(path);
+ }
+ }
+
+ return ret;
+}
+
+#define NODE_INFO_EVAL_ADD_ID(name) \
+ if (uacpi_eval_##name(node, &name) == UACPI_STATUS_OK) { \
+ size += name->size; \
+ if (uacpi_unlikely(size < name->size)) { \
+ ret = UACPI_STATUS_AML_BAD_ENCODING; \
+ goto out; \
+ } \
+ }
+
+#define NODE_INFO_COPY_ID(name, flag) \
+ if (name != UACPI_NULL) { \
+ flags |= UACPI_NS_NODE_INFO_HAS_##flag; \
+ info->name.value = cursor; \
+ info->name.size = name->size; \
+ uacpi_memcpy(cursor, name->value, name->size); \
+ cursor += name->size; \
+ } else { \
+ uacpi_memzero(&info->name, sizeof(*name)); \
+ } \
+
+uacpi_status uacpi_get_namespace_node_info(
+ uacpi_namespace_node *node, uacpi_namespace_node_info **out_info
+)
+{
+ uacpi_status ret = UACPI_STATUS_OK;
+ uacpi_u32 size = sizeof(uacpi_namespace_node_info);
+ uacpi_object *obj;
+ uacpi_namespace_node_info *info;
+ uacpi_id_string *hid = UACPI_NULL, *uid = UACPI_NULL, *cls = UACPI_NULL;
+ uacpi_pnp_id_list *cid = UACPI_NULL;
+ uacpi_char *cursor;
+ uacpi_u64 adr = 0;
+ uacpi_u8 flags = 0;
+ uacpi_u8 sxd[4], sxw[5];
+
+ obj = uacpi_namespace_node_get_object(node);
+ if (uacpi_unlikely(obj == UACPI_NULL))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ if (obj->type == UACPI_OBJECT_DEVICE ||
+ obj->type == UACPI_OBJECT_PROCESSOR) {
+ char dstate_method_template[5] = { '_', 'S', '1', 'D', '\0' };
+
+ NODE_INFO_EVAL_ADD_ID(hid)
+ NODE_INFO_EVAL_ADD_ID(uid)
+ NODE_INFO_EVAL_ADD_ID(cls)
+ NODE_INFO_EVAL_ADD_ID(cid)
+
+ if (uacpi_eval_adr(node, &adr) == UACPI_STATUS_OK)
+ flags |= UACPI_NS_NODE_INFO_HAS_ADR;
+
+ if (uacpi_eval_dstate_method_template(
+ node, dstate_method_template, sizeof(sxd), sxd
+ ) == UACPI_STATUS_OK)
+ flags |= UACPI_NS_NODE_INFO_HAS_SXD;
+
+ dstate_method_template[2] = '0';
+ dstate_method_template[3] = 'W';
+
+ if (uacpi_eval_dstate_method_template(
+ node, dstate_method_template, sizeof(sxw), sxw
+ ) == UACPI_STATUS_OK)
+ flags |= UACPI_NS_NODE_INFO_HAS_SXW;
+ }
+
+ info = uacpi_kernel_alloc(size);
+ if (uacpi_unlikely(info == UACPI_NULL)) {
+ ret = UACPI_STATUS_OUT_OF_MEMORY;
+ goto out;
+ }
+ info->size = size;
+ cursor = UACPI_PTR_ADD(info, sizeof(uacpi_namespace_node_info));
+ info->name = uacpi_namespace_node_name(node);
+ info->type = obj->type;
+ info->num_params = info->type == UACPI_OBJECT_METHOD ? obj->method->args : 0;
+
+ info->adr = adr;
+ if (flags & UACPI_NS_NODE_INFO_HAS_SXD)
+ uacpi_memcpy(info->sxd, sxd, sizeof(sxd));
+ else
+ uacpi_memzero(info->sxd, sizeof(info->sxd));
+
+ if (flags & UACPI_NS_NODE_INFO_HAS_SXW)
+ uacpi_memcpy(info->sxw, sxw, sizeof(sxw));
+ else
+ uacpi_memzero(info->sxw, sizeof(info->sxw));
+
+ if (cid != UACPI_NULL) {
+ uacpi_u32 i;
+
+ uacpi_memcpy(&info->cid, cid, cid->size + sizeof(*cid));
+ cursor += cid->num_ids * sizeof(uacpi_id_string);
+
+ for (i = 0; i < cid->num_ids; ++i) {
+ info->cid.ids[i].value = cursor;
+ cursor += info->cid.ids[i].size;
+ }
+
+ flags |= UACPI_NS_NODE_INFO_HAS_CID;
+ } else {
+ uacpi_memzero(&info->cid, sizeof(*cid));
+ }
+
+ NODE_INFO_COPY_ID(hid, HID)
+ NODE_INFO_COPY_ID(uid, UID)
+ NODE_INFO_COPY_ID(cls, CLS)
+
+out:
+ if (uacpi_likely_success(ret)) {
+ info->flags = flags;
+ *out_info = info;
+ }
+
+ uacpi_free_id_string(hid);
+ uacpi_free_id_string(uid);
+ uacpi_free_id_string(cls);
+ uacpi_free_pnp_id_list(cid);
+ return ret;
+}
+
+void uacpi_free_namespace_node_info(uacpi_namespace_node_info *info)
+{
+ if (info == UACPI_NULL)
+ return;
+
+ uacpi_free(info, info->size);
+}
+
+uacpi_bool uacpi_device_matches_pnp_id(
+ uacpi_namespace_node *node, const uacpi_char *const *ids
+)
+{
+ uacpi_status st;
+ uacpi_bool ret = UACPI_FALSE;
+ uacpi_id_string *id = UACPI_NULL;
+ uacpi_pnp_id_list *id_list = UACPI_NULL;
+
+ st = uacpi_eval_hid(node, &id);
+ if (st == UACPI_STATUS_OK && matches_any(id, ids)) {
+ ret = UACPI_TRUE;
+ goto out;
+ }
+
+ st = uacpi_eval_cid(node, &id_list);
+ if (st == UACPI_STATUS_OK) {
+ uacpi_size i;
+
+ for (i = 0; i < id_list->num_ids; ++i) {
+ if (matches_any(&id_list->ids[i], ids)) {
+ ret = UACPI_TRUE;
+ goto out;
+ }
+ }
+ }
+
+out:
+ uacpi_free_id_string(id);
+ uacpi_free_pnp_id_list(id_list);
+ return ret;
+}
+
+struct device_find_ctx {
+ const uacpi_char *const *target_hids;
+ void *user;
+ uacpi_iteration_callback cb;
+};
+
+static uacpi_iteration_decision find_one_device(
+ void *opaque, uacpi_namespace_node *node, uacpi_u32 depth
+)
+{
+ struct device_find_ctx *ctx = opaque;
+ uacpi_status ret;
+ uacpi_u32 flags;
+
+ if (!uacpi_device_matches_pnp_id(node, ctx->target_hids))
+ return UACPI_ITERATION_DECISION_CONTINUE;
+
+ ret = uacpi_eval_sta(node, &flags);
+ if (uacpi_unlikely_error(ret))
+ return UACPI_ITERATION_DECISION_NEXT_PEER;
+
+ if (!(flags & ACPI_STA_RESULT_DEVICE_PRESENT) &&
+ !(flags & ACPI_STA_RESULT_DEVICE_FUNCTIONING))
+ return UACPI_ITERATION_DECISION_NEXT_PEER;
+
+ return ctx->cb(ctx->user, node, depth);
+}
+
+
+uacpi_status uacpi_find_devices_at(
+ uacpi_namespace_node *parent, const uacpi_char *const *hids,
+ uacpi_iteration_callback cb, void *user
+)
+{
+ struct device_find_ctx ctx = { 0 };
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ ctx.target_hids = hids;
+ ctx.user = user;
+ ctx.cb = cb;
+
+ return uacpi_namespace_for_each_child(
+ parent, find_one_device, UACPI_NULL, UACPI_OBJECT_DEVICE_BIT,
+ UACPI_MAX_DEPTH_ANY, &ctx
+ );
+}
+
+uacpi_status uacpi_find_devices(
+ const uacpi_char *hid, uacpi_iteration_callback cb, void *user
+)
+{
+ const uacpi_char *hids[2] = {
+ UACPI_NULL, UACPI_NULL
+ };
+
+ hids[0] = hid;
+
+ return uacpi_find_devices_at(uacpi_namespace_root(), hids, cb, user);
+}
+
+uacpi_status uacpi_set_interrupt_model(uacpi_interrupt_model model)
+{
+ uacpi_status ret;
+ uacpi_object *arg;
+ uacpi_object_array args;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ arg = uacpi_create_object(UACPI_OBJECT_INTEGER);
+ if (uacpi_unlikely(arg == UACPI_NULL))
+ return UACPI_STATUS_OUT_OF_MEMORY;
+
+ arg->integer = model;
+ args.objects = &arg;
+ args.count = 1;
+
+ ret = uacpi_eval(uacpi_namespace_root(), "_PIC", &args, UACPI_NULL);
+ uacpi_object_unref(arg);
+
+ if (ret == UACPI_STATUS_NOT_FOUND)
+ ret = UACPI_STATUS_OK;
+
+ return ret;
+}
+
+uacpi_status uacpi_get_pci_routing_table(
+ uacpi_namespace_node *parent, uacpi_pci_routing_table **out_table
+)
+{
+ uacpi_status ret;
+ uacpi_object *obj, *entry_obj, *elem_obj;
+ uacpi_package *table_pkg, *entry_pkg;
+ uacpi_pci_routing_table_entry *entry;
+ uacpi_pci_routing_table *table;
+ uacpi_size size, i;
+
+ UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
+
+ obj = uacpi_namespace_node_get_object(parent);
+ if (uacpi_unlikely(obj == UACPI_NULL || obj->type != UACPI_OBJECT_DEVICE))
+ return UACPI_STATUS_INVALID_ARGUMENT;
+
+ ret = uacpi_eval_typed(
+ parent, "_PRT", UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, &obj
+ );
+ if (uacpi_unlikely_error(ret))
+ return ret;
+
+ table_pkg = obj->package;
+ if (uacpi_unlikely(table_pkg->count == 0 || table_pkg->count > 1024)) {
+ uacpi_error("invalid number of _PRT entries: %zu\n", table_pkg->count);
+ uacpi_object_unref(obj);
+ return UACPI_STATUS_AML_BAD_ENCODING;
+ }
+
+ size = table_pkg->count * sizeof(uacpi_pci_routing_table_entry);
+ table = uacpi_kernel_alloc(sizeof(uacpi_pci_routing_table) + size);
+ if (uacpi_unlikely(table == UACPI_NULL)) {
+ uacpi_object_unref(obj);
+ return UACPI_STATUS_OUT_OF_MEMORY;
+ }
+ table->num_entries = table_pkg->count;
+
+ for (i = 0; i < table_pkg->count; ++i) {
+ entry_obj = table_pkg->objects[i];
+
+ if (uacpi_unlikely(entry_obj->type != UACPI_OBJECT_PACKAGE)) {
+ uacpi_error("_PRT sub-object %zu is not a package: %s\n",
+ i, uacpi_object_type_to_string(entry_obj->type));
+ goto out_bad_encoding;
+ }
+
+ entry_pkg = entry_obj->package;
+ if (uacpi_unlikely(entry_pkg->count != 4)) {
+ uacpi_error("invalid _PRT sub-package entry count %zu\n",
+ entry_pkg->count);
+ goto out_bad_encoding;
+ }
+
+ entry = &table->entries[i];
+
+ elem_obj = entry_pkg->objects[0];
+ if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
+ uacpi_error("invalid _PRT sub-package %zu address type: %s\n",
+ i, uacpi_object_type_to_string(elem_obj->type));
+ goto out_bad_encoding;
+ }
+ entry->address = elem_obj->integer;
+
+ elem_obj = entry_pkg->objects[1];
+ if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
+ uacpi_error("invalid _PRT sub-package %zu pin type: %s\n",
+ i, uacpi_object_type_to_string(elem_obj->type));
+ goto out_bad_encoding;
+ }
+ entry->pin = elem_obj->integer;
+
+ elem_obj = entry_pkg->objects[2];
+ switch (elem_obj->type) {
+ case UACPI_OBJECT_STRING:
+ ret = uacpi_object_resolve_as_aml_namepath(
+ elem_obj, parent, &entry->source
+ );
+ if (uacpi_unlikely_error(ret)) {
+ uacpi_error("unable to lookup _PRT source %s: %s\n",
+ elem_obj->buffer->text, uacpi_status_to_string(ret));
+ goto out_bad_encoding;
+ }
+ break;
+ case UACPI_OBJECT_INTEGER:
+ entry->source = UACPI_NULL;
+ break;
+ default:
+ uacpi_error("invalid _PRT sub-package %zu source type: %s\n",
+ i, uacpi_object_type_to_string(elem_obj->type));
+ goto out_bad_encoding;
+ }
+
+ elem_obj = entry_pkg->objects[3];
+ if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
+ uacpi_error("invalid _PRT sub-package %zu source index type: %s\n",
+ i, uacpi_object_type_to_string(elem_obj->type));
+ goto out_bad_encoding;
+ }
+ entry->index = elem_obj->integer;
+ }
+
+ uacpi_object_unref(obj);
+ *out_table = table;
+ return UACPI_STATUS_OK;
+
+out_bad_encoding:
+ uacpi_object_unref(obj);
+ uacpi_free_pci_routing_table(table);
+ return UACPI_STATUS_AML_BAD_ENCODING;
+}
+
+void uacpi_free_pci_routing_table(uacpi_pci_routing_table *table)
+{
+ if (table == UACPI_NULL)
+ return;
+
+ uacpi_free(
+ table,
+ sizeof(uacpi_pci_routing_table) +
+ table->num_entries * sizeof(uacpi_pci_routing_table_entry)
+ );
+}
+
+void uacpi_free_dynamic_string(const uacpi_char *str)
+{
+ if (str == UACPI_NULL)
+ return;
+
+ uacpi_free((void*)str, uacpi_strlen(str) + 1);
+}
+
+#endif // !UACPI_BAREBONES_MODE
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-18 20:05:37 +0000