uacpi.h File Reference

#include <uacpi/types.h>
#include <uacpi/status.h>
#include <uacpi/kernel_api.h>
#include <uacpi/namespace.h>

Include dependency graph for uacpi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	UACPI_MAJOR   7
#define	UACPI_MINOR   0
#define	UACPI_PATCH   0
#define	UACPI_STUB_IF_REDUCED_HARDWARE(fn)   fn;
#define	UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(fn)   fn;
#define	UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE(fn)   fn;
#define	UACPI_FLAG_BAD_CSUM_FATAL   (1ull << 0)
#define	UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL   (1ull << 1)
#define	UACPI_FLAG_BAD_XSDT   (1ull << 2)
#define	UACPI_FLAG_NO_ACPI_MODE   (1ull << 3)
#define	UACPI_FLAG_NO_OSI   (1ull << 4)
#define	UACPI_FLAG_PROACTIVE_TBL_CSUM   (1ull << 5)

Functions
uacpi_status	uacpi_setup_early_table_access (void *temporary_buffer, uacpi_size buffer_size)
uacpi_bool	uacpi_table_subsystem_available (void)
uacpi_status	uacpi_is_platform_reduced_hardware (uacpi_bool *out_value)
uacpi_status	uacpi_initialize (uacpi_u64 flags)
uacpi_status	uacpi_namespace_load (void)
uacpi_status	uacpi_namespace_initialize (void)
uacpi_init_level	uacpi_get_current_init_level (void)
uacpi_status	uacpi_eval (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **ret)
uacpi_status	uacpi_eval_simple (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret)
uacpi_status	uacpi_execute (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args)
uacpi_status	uacpi_execute_simple (uacpi_namespace_node *parent, const uacpi_char *path)
uacpi_status	uacpi_eval_typed (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object_type_bits ret_mask, uacpi_object **ret)
uacpi_status	uacpi_eval_simple_typed (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object_type_bits ret_mask, uacpi_object **ret)
uacpi_status	uacpi_eval_integer (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_u64 *out_value)
uacpi_status	uacpi_eval_simple_integer (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_u64 *out_value)
uacpi_status	uacpi_eval_string_or_buffer (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **ret)
uacpi_status	uacpi_eval_simple_string_or_buffer (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret)
uacpi_status	uacpi_eval_string (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **ret)
uacpi_status	uacpi_eval_simple_string (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret)
uacpi_status	uacpi_eval_buffer (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **ret)
uacpi_status	uacpi_eval_simple_buffer (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret)
uacpi_status	uacpi_eval_package (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **ret)
uacpi_status	uacpi_eval_simple_package (uacpi_namespace_node *parent, const uacpi_char *path, uacpi_object **ret)
uacpi_status	uacpi_get_aml_bitness (uacpi_u8 *out_bitness)
	UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE (uacpi_status uacpi_enter_acpi_mode(void)) UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE(uacpi_status uacpi_leave_acpi_mode(void)) uacpi_status uacpi_acquire_global_lock(uacpi_u16 timeout
uacpi_status	uacpi_release_global_lock (uacpi_u32 seq)
void	uacpi_state_reset (void)

Variables
uacpi_u32 *	out_seq

Macro Definition Documentation

UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE

#define UACPI_ALWAYS_ERROR_FOR_REDUCED_HARDWARE

(

fn

)

fn;

Definition at line 27 of file uacpi.h.

UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE

#define UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE

(

fn

)

fn;

Definition at line 28 of file uacpi.h.

UACPI_FLAG_BAD_CSUM_FATAL

#define UACPI_FLAG_BAD_CSUM_FATAL   (1ull << 0)

Bad table checksum should be considered a fatal error (table load is fully aborted in this case)

Definition at line 75 of file uacpi.h.

UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL

#define UACPI_FLAG_BAD_TBL_SIGNATURE_FATAL   (1ull << 1)

Unexpected table signature should be considered a fatal error (table load is fully aborted in this case)

Definition at line 81 of file uacpi.h.

UACPI_FLAG_BAD_XSDT

#define UACPI_FLAG_BAD_XSDT   (1ull << 2)

Force uACPI to use RSDT even for later revisions

Definition at line 86 of file uacpi.h.

UACPI_FLAG_NO_ACPI_MODE

#define UACPI_FLAG_NO_ACPI_MODE   (1ull << 3)

If this is set, ACPI mode is not entered during the call to uacpi_initialize. The caller is expected to enter it later at their own discretion by using uacpi_enter_acpi_mode().

Definition at line 93 of file uacpi.h.

UACPI_FLAG_NO_OSI

#define UACPI_FLAG_NO_OSI   (1ull << 4)

Don't create the _OSI method when building the namespace. Only enable this if you're certain that having this method breaks your AML blob, a more atomic/granular interface management is available via osi.h

Definition at line 100 of file uacpi.h.

UACPI_FLAG_PROACTIVE_TBL_CSUM

#define UACPI_FLAG_PROACTIVE_TBL_CSUM   (1ull << 5)

Validate table checksums at installation time instead of first use. Note that this makes uACPI map the entire table at once, which not all hosts are able to handle at early init.

Definition at line 107 of file uacpi.h.

UACPI_MAJOR

#define UACPI_MAJOR   7

Definition at line 8 of file uacpi.h.

UACPI_MINOR

#define UACPI_MINOR   0

Definition at line 9 of file uacpi.h.

UACPI_PATCH

#define UACPI_PATCH   0

Definition at line 10 of file uacpi.h.

UACPI_STUB_IF_REDUCED_HARDWARE

#define UACPI_STUB_IF_REDUCED_HARDWARE

(

fn

)

fn;

Definition at line 26 of file uacpi.h.

Function Documentation

UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE()

UACPI_ALWAYS_OK_FOR_REDUCED_HARDWARE

(

uacpi_status

uacpi_enter_acpi_modevoid

)

Helpers for entering & leaving ACPI mode. Note that ACPI mode is entered automatically during the call to uacpi_initialize(). Attempt to acquire the global lock for 'timeout' milliseconds. 0xFFFF implies infinite wait.

On success, 'out_seq' is set to a unique sequence number for the current acquire transaction. This number is used for validation during release.

uacpi_eval()

uacpi_status uacpi_eval	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object **	ret
	)

Evaluate an object within the namespace and get back its value. Either root or path must be valid. A value of NULL for 'parent' implies uacpi_namespace_root() relative lookups, unless 'path' is already absolute.

Definition at line 721 of file uacpi.c.

{
    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;
}

Referenced by eval_sleep_helper(), ini_eval(), uacpi_eval_simple(), uacpi_eval_typed(), uacpi_execute(), uacpi_execute_simple(), uacpi_set_interrupt_model(), and uacpi_set_resources().

uacpi_eval_buffer()

uacpi_status uacpi_eval_buffer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object **	ret
	)

A shorthand for uacpi_eval_typed with UACPI_OBJECT_BUFFER_BIT.

Use uacpi_object_get_buffer to retrieve the resulting buffer data.

Definition at line 973 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, args, UACPI_OBJECT_BUFFER_BIT, ret
    );
}

uacpi_eval_integer()

uacpi_status uacpi_eval_integer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_u64 *	out_value
	)

A shorthand for uacpi_eval_typed with UACPI_OBJECT_INTEGER_BIT.

Definition at line 904 of file uacpi.c.

{
    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;
}

Referenced by uacpi_eval_adr(), uacpi_eval_simple_integer(), and uacpi_eval_sta().

uacpi_eval_package()

uacpi_status uacpi_eval_package	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object **	ret
	)

A shorthand for uacpi_eval_typed with UACPI_OBJECT_PACKAGE_BIT.

Use uacpi_object_get_package to retrieve the resulting object array.

Definition at line 992 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, args, UACPI_OBJECT_PACKAGE_BIT, ret
    );
}

uacpi_eval_simple()

uacpi_status uacpi_eval_simple	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object **	ret
	)

Definition at line 799 of file uacpi.c.

{
    return uacpi_eval(parent, path, UACPI_NULL, ret);
}

uacpi_eval_simple_buffer()

uacpi_status uacpi_eval_simple_buffer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object **	ret
	)

Definition at line 983 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, UACPI_NULL, UACPI_OBJECT_BUFFER_BIT, ret
    );
}

Referenced by eval_resource_helper().

uacpi_eval_simple_integer()

uacpi_status uacpi_eval_simple_integer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_u64 *	out_value
	)

Definition at line 924 of file uacpi.c.

{
    return uacpi_eval_integer(parent, path, UACPI_NULL, out_value);
}

Referenced by pci_region_attach(), pci_region_collect_devices(), and pci_region_find_devices().

uacpi_eval_simple_package()

uacpi_status uacpi_eval_simple_package	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object **	ret
	)

Definition at line 1002 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, ret
    );
}

uacpi_eval_simple_string()

uacpi_status uacpi_eval_simple_string	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object **	ret
	)

Definition at line 964 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, UACPI_NULL, UACPI_OBJECT_STRING_BIT, ret
    );
}

uacpi_eval_simple_string_or_buffer()

uacpi_status uacpi_eval_simple_string_or_buffer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object **	ret
	)

Definition at line 943 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, UACPI_NULL,
        UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT,
        ret
    );
}

uacpi_eval_simple_typed()

uacpi_status uacpi_eval_simple_typed	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		uacpi_object_type_bits	ret_mask,
		uacpi_object **	ret
	)

Definition at line 896 of file uacpi.c.

{
    return uacpi_eval_typed(parent, path, UACPI_NULL, ret_mask, ret);
}

uacpi_eval_string()

uacpi_status uacpi_eval_string	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object **	ret
	)

A shorthand for uacpi_eval_typed with UACPI_OBJECT_STRING_BIT.

Use uacpi_object_get_string to retrieve the resulting buffer data.

Definition at line 954 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, args, UACPI_OBJECT_STRING_BIT, ret
    );
}

uacpi_eval_string_or_buffer()

uacpi_status uacpi_eval_string_or_buffer	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object **	ret
	)

A shorthand for uacpi_eval_typed with UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT

Use uacpi_object_get_string_or_buffer to retrieve the resulting buffer data.

Definition at line 931 of file uacpi.c.

{
    return uacpi_eval_typed(
        parent, path, args,
        UACPI_OBJECT_BUFFER_BIT | UACPI_OBJECT_STRING_BIT,
        ret
    );
}

uacpi_eval_typed()

uacpi_status uacpi_eval_typed	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args,
		uacpi_object_type_bits	ret_mask,
		uacpi_object **	ret
	)

Same as uacpi_eval, but the return value type is validated against the 'ret_mask'. UACPI_STATUS_TYPE_MISMATCH is returned on error.

Definition at line 866 of file uacpi.c.

{
    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;
}

Referenced by get_slp_type_for_state(), uacpi_eval_buffer(), uacpi_eval_cid(), uacpi_eval_cls(), uacpi_eval_dstate_method_template(), uacpi_eval_hid(), uacpi_eval_integer(), uacpi_eval_package(), uacpi_eval_simple_buffer(), uacpi_eval_simple_package(), uacpi_eval_simple_string(), uacpi_eval_simple_string_or_buffer(), uacpi_eval_simple_typed(), uacpi_eval_string(), uacpi_eval_string_or_buffer(), uacpi_eval_uid(), and uacpi_get_pci_routing_table().

uacpi_execute()

uacpi_status uacpi_execute	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path,
		const uacpi_object_array *	args
	)

Same as uacpi_eval() but without a return value.

Definition at line 806 of file uacpi.c.

{
    return uacpi_eval(parent, path, args, UACPI_NULL);
}

uacpi_execute_simple()

uacpi_status uacpi_execute_simple	(	uacpi_namespace_node *	parent,
		const uacpi_char *	path
	)

Definition at line 814 of file uacpi.c.

{
    return uacpi_eval(parent, path, UACPI_NULL, UACPI_NULL);
}

uacpi_get_aml_bitness()

uacpi_status uacpi_get_aml_bitness

(

uacpi_u8 *

out_bitness

)

Get the bitness of the currently loaded AML code according to the DSDT.

Returns either 32 or 64.

Definition at line 1011 of file uacpi.c.

{
    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;
}

Referenced by uacpi_object_create_integer_safe().

uacpi_get_current_init_level()

uacpi_init_level uacpi_get_current_init_level

(

void

)

Definition at line 322 of file uacpi.c.

{
    return g_uacpi_rt_ctx.init_level;
}

Referenced by uacpi_initialize_opregion_node().

uacpi_initialize()

uacpi_status uacpi_initialize

(

uacpi_u64

flags

)

Initializes the uACPI subsystem, iterates & records all relevant RSDT/XSDT tables. Enters ACPI mode.

'flags' is any combination of UACPI_FLAG_* above

Definition at line 327 of file uacpi.c.

{
    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;
}

Referenced by ACPIInitUACPI().

uacpi_is_platform_reduced_hardware()

uacpi_status uacpi_is_platform_reduced_hardware

(

uacpi_bool *

out_value

)

Returns UACPI_TRUE via 'out_value' if the current platform is reduced ACPI hardware, UACPI_FALSE otherwise.

This getter becomes available along with the table subsystem, use uacpi_table_subsystem_available() to check.

Definition at line 20 of file uacpi.c.

{
    if (!uacpi_table_subsystem_available())
        return UACPI_STATUS_INIT_LEVEL_MISMATCH;
 
    *out_value = uacpi_is_hardware_reduced();
    return UACPI_STATUS_OK;
}

uacpi_namespace_initialize()

uacpi_status uacpi_namespace_initialize

(

void

)

Initializes all the necessary objects in the namespaces by calling _STA/_INI etc.

Definition at line 632 of file uacpi.c.

{
    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",
            UACPI_FMT64(elapsed_ms(begin_ts, end_ts)),
            ctx.devices, ctx.thermal_zones
        );
    } else {
        uacpi_info(
            "namespace initialization done: %zu devices, %zu thermal zones",
            ctx.devices, ctx.thermal_zones
        );
    }
 
    uacpi_trace(
        "_STA calls: %zu (%zu errors), _INI calls: %zu (%zu errors)",
        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_namespace_load()

uacpi_status uacpi_namespace_load

(

void

)

Parses & executes all of the DSDT/SSDT tables. Initializes the event subsystem.

Definition at line 449 of file uacpi.c.

{
    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", 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)",
            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)",
            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",
                    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;
}

uacpi_release_global_lock()

uacpi_status uacpi_release_global_lock

(

uacpi_u32

seq

)

Definition at line 176 of file mutex.c.

{
    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_setup_early_table_access()

uacpi_status uacpi_setup_early_table_access	(	void *	temporary_buffer,
		uacpi_size	buffer_size
	)

Set up early access to the table subsystem. What this means is:

• uacpi_table_find() and similar API becomes usable before the call to uacpi_initialize().
• No kernel API besides logging and map/unmap will be invoked at this stage, allowing for heap and scheduling to still be fully offline.
• The provided 'temporary_buffer' will be used as a temporary storage for the internal metadata about the tables (list, reference count, addresses, sizes, etc).
• The 'temporary_buffer' is replaced with a normal heap buffer allocated via uacpi_kernel_alloc() after the call to uacpi_initialize() and can therefore be reclaimed by the kernel.

The 'temporary_buffer' is expected to be aligned on the native pointer size boundary (4 on a 32-bit system, 8 on a 64-bit system), although any misalignment is handled gracefully and does not result in an error.

The approximate overhead per table is 56 bytes, so a buffer of 4096 bytes yields about 73 tables in terms of capacity. uACPI also has an internal static buffer for tables, "UACPI_STATIC_TABLE_ARRAY_LEN", which is configured as 16 descriptors in length by default.

This function is used to initialize the barebones mode, see UACPI_BAREBONES_MODE in config.h for more information.

Definition at line 216 of file tables.c.

{
    uacpi_status ret;
    uacpi_virt_addr buffer_addr, aligned_buffer_addr;
 
#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;
 
    uacpi_logger_initialize();
 
    buffer_addr = UACPI_PTR_TO_VIRT_ADDR(temporary_buffer);
    aligned_buffer_addr = UACPI_ALIGN_UP(
        buffer_addr, UACPI_POINTER_SIZE, uacpi_virt_addr
    );
    if (buffer_addr != aligned_buffer_addr) {
        uacpi_size stripped_bytes;
 
        stripped_bytes = aligned_buffer_addr - buffer_addr;
        uacpi_warn(
            "fixed up misaligned early tables buffer (%zu bytes stripped)",
            stripped_bytes
        );
 
        buffer_size -= UACPI_MIN(stripped_bytes, buffer_size);
        temporary_buffer = UACPI_VIRT_ADDR_TO_PTR(aligned_buffer_addr);
    }
 
    if (uacpi_unlikely(buffer_size < sizeof(struct uacpi_installed_table)))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    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;
}

uacpi_state_reset()

void uacpi_state_reset

(

void

)

Reset the global uACPI state by freeing all internally allocated data structures & resetting any global variables. After this call, uACPI must be re-initialized from scratch to be used again.

This is called by uACPI automatically if a fatal error occurs during a call to uacpi_initialize/uacpi_namespace_load etc. in order to prevent accidental use of partially uninitialized subsystems.

NOTE:

• This waits for all of the in-flight interrupts & deferred work to complete, see uacpi_kernel_wait_for_work_completion, and therefore must not be called from an interrupt handler, nor from any work that was scheduled via uacpi_kernel_schedule_work
• That is all it waits for: it's up to the caller to make sure that no other thread is in the middle of a call into uACPI, or is about to make one, as everything that such a call relies on is gone once this returns

Definition at line 136 of file uacpi.c.

{
#ifndef UACPI_BAREBONES_MODE
    /*
     * Get rid of everything that is able to produce deferred work first, and
     * then make sure there's none left, be it a GPE handler or a notification.
     * Neither would survive the namespace being torn down underneath it.
     */
    uacpi_deinitialize_events();
 
    if (g_uacpi_rt_ctx.init_level >= UACPI_INIT_LEVEL_SUBSYSTEM_INITIALIZED)
        uacpi_kernel_wait_for_work_completion();
 
    uacpi_deinitialize_namespace();
    uacpi_deinitialize_interfaces();
    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_free_native_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
}

Referenced by uacpi_initialize(), uacpi_namespace_initialize(), and uacpi_namespace_load().

uacpi_table_subsystem_available()

uacpi_bool uacpi_table_subsystem_available

(

void

)

Returns UACPI_TRUE if the table subsystem is available for use by the kernel. This happens after a successful call to either uacpi_initialize(...) or uacpi_setup_early_table_access(...).

Referenced by uacpi_is_platform_reduced_hardware().

Variable Documentation

out_seq

uacpi_u32* out_seq

Definition at line 271 of file uacpi.h.

Referenced by uacpi_acquire_global_lock().