uacpi.c File Reference

#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/mutex.h>

Include dependency graph for uacpi.c:

Go to the source code of this file.

Classes
struct	table_load_stats
struct	ns_init_context

Macros
#define	TRACE_BAD_RET(path_fmt, type, ...)
#define	TRACE_NO_RET(path_fmt, ...)

Enumerations
enum	hw_mode { HW_MODE_ACPI = 0 , HW_MODE_LEGACY = 1 }

Functions
uacpi_status	uacpi_is_platform_reduced_hardware (uacpi_bool *out_value)
void	uacpi_context_set_log_level (uacpi_log_level lvl)
void	uacpi_logger_initialize (void)
void	uacpi_context_set_proactive_table_checksum (uacpi_bool setting)
const uacpi_char *	uacpi_status_to_string (uacpi_status st)
void	uacpi_state_reset (void)
void	uacpi_context_set_loop_timeout (uacpi_u32 seconds)
void	uacpi_context_set_max_call_stack_depth (uacpi_u32 depth)
uacpi_u32	uacpi_context_get_loop_timeout (void)
static enum hw_mode	read_mode (void)
static uacpi_status	set_mode (enum hw_mode mode)
static uacpi_status	enter_mode (enum hw_mode mode, uacpi_bool *did_change)
uacpi_status	uacpi_enter_acpi_mode (void)
uacpi_status	uacpi_leave_acpi_mode (void)
static void	enter_acpi_mode_initial (void)
uacpi_init_level	uacpi_get_current_init_level (void)
uacpi_status	uacpi_initialize (uacpi_u64 flags)
static void	trace_table_load_failure (struct acpi_sdt_hdr *tbl, uacpi_log_level lvl, uacpi_status ret)
static uacpi_bool	match_ssdt_or_psdt (struct uacpi_installed_table *tbl)
static uacpi_u64	elapsed_ms (uacpi_u64 begin_ns, uacpi_u64 end_ns)
static uacpi_bool	warn_on_bad_timesource (uacpi_u64 begin_ts, uacpi_u64 end_ts)
uacpi_status	uacpi_namespace_load (void)
static void	ini_eval (struct ns_init_context *ctx, uacpi_namespace_node *node)
static uacpi_status	sta_eval (struct ns_init_context *ctx, uacpi_namespace_node *node, uacpi_u32 *value)
static uacpi_iteration_decision	do_sta_ini (void *opaque, uacpi_namespace_node *node, uacpi_u32 depth)
uacpi_status	uacpi_namespace_initialize (void)
uacpi_status	uacpi_eval (uacpi_namespace_node *parent, const uacpi_char *path, const uacpi_object_array *args, uacpi_object **out_obj)
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)
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)
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	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)

Variables
struct uacpi_runtime_context	g_uacpi_rt_ctx = { 0 }

Macro Definition Documentation

TRACE_BAD_RET

#define TRACE_BAD_RET	(		path_fmt,
			type,
			...
	)

Value:

    uacpi_warn(                                                            \
        "unexpected '%s' object returned by method "path_fmt               \
        ", expected type mask: %08X", uacpi_object_type_to_string(type),   \
        __VA_ARGS__                                                        \
    )

Definition at line 821 of file uacpi.c.

TRACE_NO_RET

#define TRACE_NO_RET	(		path_fmt,
			...
	)

Value:

    uacpi_warn(                                                            \
        "no value returned from method "path_fmt", expected type mask: "   \
        "%08X", __VA_ARGS__                                                \
    )

Definition at line 828 of file uacpi.c.

Enumeration Type Documentation

hw_mode

enum hw_mode

Enumerator
HW_MODE_ACPI
HW_MODE_LEGACY

Definition at line 206 of file uacpi.c.

             {
    HW_MODE_ACPI = 0,
    HW_MODE_LEGACY = 1,
};

Function Documentation

do_sta_ini()

static uacpi_iteration_decision do_sta_ini ( void *  opaque, uacpi_namespace_node *  node, uacpi_u32  depth  )

static

Definition at line 578 of file uacpi.c.

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

Referenced by uacpi_namespace_initialize().

elapsed_ms()

static uacpi_u64 elapsed_ms ( uacpi_u64  begin_ns, uacpi_u64  end_ns  )

static

Definition at line 418 of file uacpi.c.

{
    return (end_ns - begin_ns) / (1000ull * 1000ull);
}

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

enter_acpi_mode_initial()

static void enter_acpi_mode_initial ( void  )

static

Definition at line 314 of file uacpi.c.

{
    enter_mode(HW_MODE_ACPI, &g_uacpi_rt_ctx.was_in_legacy_mode);
}

Referenced by uacpi_initialize().

enter_mode()

static uacpi_status enter_mode ( enum hw_mode  mode, uacpi_bool *  did_change  )

static

Definition at line 271 of file uacpi.c.

{
    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", mode_str);
        return UACPI_STATUS_OK;
    }
 
    ret = set_mode(mode);
    if (uacpi_unlikely_error(ret)) {
        uacpi_warn(
            "unable to enter %s mode: %s",
            mode_str, uacpi_status_to_string(ret)
        );
        return ret;
    }
 
    uacpi_trace("entered %s mode", mode_str);
    if (did_change != UACPI_NULL)
        *did_change = UACPI_TRUE;
 
    return ret;
}

Referenced by enter_acpi_mode_initial(), uacpi_enter_acpi_mode(), and uacpi_leave_acpi_mode().

ini_eval()

static void ini_eval ( struct ns_init_context *  ctx, uacpi_namespace_node *  node  )

static

Definition at line 547 of file uacpi.c.

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

Referenced by do_sta_ini(), and uacpi_namespace_initialize().

match_ssdt_or_psdt()

static uacpi_bool match_ssdt_or_psdt ( struct uacpi_installed_table *  tbl )

static

Definition at line 409 of file uacpi.c.

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

Referenced by uacpi_namespace_load().

read_mode()

static enum hw_mode read_mode ( void  )

static

Definition at line 211 of file uacpi.c.

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

Referenced by enter_mode(), and set_mode().

set_mode()

static uacpi_status set_mode ( enum hw_mode  mode )

static

Definition at line 227 of file uacpi.c.

{
    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");
        return UACPI_STATUS_NOT_FOUND;
    }
 
    if (uacpi_unlikely(!fadt->acpi_enable && !fadt->acpi_disable)) {
        uacpi_error("mode transition is not implemented by the hardware");
        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");
    return UACPI_STATUS_HARDWARE_TIMEOUT;
}

Referenced by enter_mode(), and FT_Set_Renderer().

sta_eval()

static uacpi_status sta_eval ( struct ns_init_context *  ctx, uacpi_namespace_node *  node, uacpi_u32 *  value  )

static

Definition at line 560 of file uacpi.c.

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

Referenced by do_sta_ini().

trace_invalid_return_type()

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  )

static

Definition at line 834 of file uacpi.c.

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

Referenced by uacpi_eval_typed().

trace_table_load_failure()

static void trace_table_load_failure ( struct acpi_sdt_hdr *  tbl, uacpi_log_level  lvl, uacpi_status  ret  )

static

Definition at line 398 of file uacpi.c.

{
    uacpi_log_lvl(
        lvl,
        "failed to load "UACPI_PRI_TBL_HDR": %s",
        UACPI_FMT_TBL_HDR(tbl), uacpi_status_to_string(ret)
    );
}

Referenced by uacpi_namespace_load().

uacpi_context_get_loop_timeout()

uacpi_u32 uacpi_context_get_loop_timeout

(

void

)

Definition at line 200 of file uacpi.c.

{
    return g_uacpi_rt_ctx.loop_timeout_seconds;
}

uacpi_context_set_log_level()

void uacpi_context_set_log_level

(

uacpi_log_level

lvl

)

Set the minimum log level to be accepted by the logging facilities. Any logs below this level are discarded and not passed to uacpi_kernel_log, etc.

0 is treated as a special value that resets the setting to the default value.

E.g. for a log level of UACPI_LOG_INFO: UACPI_LOG_DEBUG -> discarded UACPI_LOG_TRACE -> discarded UACPI_LOG_INFO -> allowed UACPI_LOG_WARN -> allowed UACPI_LOG_ERROR -> allowed

Definition at line 29 of file uacpi.c.

{
    if (lvl == 0)
        lvl = UACPI_DEFAULT_LOG_LEVEL;
 
    g_uacpi_rt_ctx.log_level = lvl;
}

Referenced by uacpi_logger_initialize().

uacpi_context_set_loop_timeout()

void uacpi_context_set_loop_timeout

(

uacpi_u32

seconds

)

Set the maximum number of seconds a While loop is allowed to run for before getting timed out.

0 is treated a special value that resets the setting to the default value.

Definition at line 184 of file uacpi.c.

{
    if (seconds == 0)
        seconds = UACPI_DEFAULT_LOOP_TIMEOUT_SECONDS;
 
    g_uacpi_rt_ctx.loop_timeout_seconds = seconds;
}

Referenced by uacpi_initialize().

uacpi_context_set_max_call_stack_depth()

void uacpi_context_set_max_call_stack_depth

(

uacpi_u32

depth

)

Set the maximum call stack depth AML can reach before getting aborted.

0 is treated as a special value that resets the setting to the default value.

Definition at line 192 of file uacpi.c.

{
    if (depth == 0)
        depth = UACPI_DEFAULT_MAX_CALL_STACK_DEPTH;
 
    g_uacpi_rt_ctx.max_call_stack_depth = depth;
}

Referenced by uacpi_initialize().

uacpi_context_set_proactive_table_checksum()

void uacpi_context_set_proactive_table_checksum

(

uacpi_bool

setting

)

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

Definition at line 53 of file uacpi.c.

{
    if (setting)
        g_uacpi_rt_ctx.flags |= UACPI_FLAG_PROACTIVE_TBL_CSUM;
    else
        g_uacpi_rt_ctx.flags &= ~UACPI_FLAG_PROACTIVE_TBL_CSUM;
}

uacpi_enter_acpi_mode()

uacpi_status uacpi_enter_acpi_mode

(

void

)

Definition at line 304 of file uacpi.c.

{
    return enter_mode(HW_MODE_ACPI, UACPI_NULL);
}

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_leave_acpi_mode()

uacpi_status uacpi_leave_acpi_mode

(

void

)

Definition at line 309 of file uacpi.c.

{
    return enter_mode(HW_MODE_LEGACY, UACPI_NULL);
}

Referenced by uacpi_state_reset().

uacpi_logger_initialize()

void uacpi_logger_initialize

(

void

)

Definition at line 37 of file uacpi.c.

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

Referenced by uacpi_initialize(), and uacpi_setup_early_table_access().

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_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_status_to_string()

const uacpi_char * uacpi_status_to_string

(

uacpi_status

st

)

Definition at line 61 of file uacpi.c.

{
    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";
    case UACPI_STATUS_AML_REFERENCE_CYCLE:
        return "AML attempted to create a reference cycle";
    default:
        return "<invalid status>";
    }
}

Referenced by ACPIInitUACPI(), async_restore_gpe(), async_run_gpe_handler(), dispatch_gpe(), do_initialize_gpe_block(), do_match_gpe_methods(), enter_mode(), eval_sleep_helper(), get_slp_type_for_state(), gpe_mask_and_flush(), initialize_gpes(), report_table_id_find_error(), run_reg(), trace_named_object_lookup_or_creation_failure(), trace_table_load_failure(), uacpi_eval_dstate_method_template(), uacpi_execute_control_method(), uacpi_get_pci_routing_table(), uacpi_initialize_events(), uacpi_namespace_load(), and uacpi_trace_region_error().

warn_on_bad_timesource()

static uacpi_bool warn_on_bad_timesource ( uacpi_u64  begin_ts, uacpi_u64  end_ts  )

static

Definition at line 423 of file uacpi.c.

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

Referenced by uacpi_namespace_load().

Variable Documentation

g_uacpi_rt_ctx

struct uacpi_runtime_context g_uacpi_rt_ctx = { 0 }

Definition at line 18 of file uacpi.c.

Referenced by begin_block_execution(), buffer_field_get_read_type(), debug_store_no_recurse(), do_binary_math(), do_notify(), DYNAMIC_ARRAY_WITH_INLINE_STORAGE(), enter_acpi_mode_initial(), enter_sleep_state_hw_full(), enter_sleep_state_hw_reduced(), extract_handlers(), fadt_relative(), find_or_create_gpe_interrupt_ctx(), get_op(), handle_global_lock(), initialize_fadt(), initialize_from_rsdp(), initialize_gpes(), lock_field_unit_transaction(), make_object_for_predefined(), ones(), prepare_for_wake_from_sleep_state_hw_full(), prepare_for_wake_from_sleep_state_hw_reduced(), prepare_method_call(), read_mode(), set_mode(), sizeof_int(), split_event_blocks(), truncate_number_if_needed(), uacpi_acquire_aml_mutex(), uacpi_acquire_global_lock(), uacpi_acquire_global_lock_from_firmware(), uacpi_check_flag(), uacpi_context_get_loop_timeout(), uacpi_context_set_log_level(), uacpi_context_set_loop_timeout(), uacpi_context_set_max_call_stack_depth(), uacpi_context_set_proactive_table_checksum(), uacpi_deinitialize_events(), uacpi_deinitialize_namespace(), uacpi_enter_sleep_state(), uacpi_field_unit_get_read_type(), uacpi_get_aml_bitness(), uacpi_get_current_init_level(), uacpi_initialize(), uacpi_initialize_events(), uacpi_initialize_tables(), uacpi_install_address_space_handler_with_flags(), uacpi_install_notify_handler(), uacpi_is_hardware_reduced(), uacpi_logger_initialize(), uacpi_namespace_initialize(), uacpi_namespace_load(), uacpi_node_get_address_space_handlers(), uacpi_notify_all(), uacpi_prepare_for_sleep_state(), uacpi_reboot(), uacpi_release_aml_mutex(), uacpi_release_global_lock(), uacpi_release_global_lock_to_firmware(), uacpi_set_waking_vector(), uacpi_should_log(), uacpi_state_reset(), uacpi_table_fadt(), uacpi_uninstall_notify_handler(), uninstall_gpe_block(), unlink_gpe_interrupt_ctx(), unlock_field_unit_transaction(), verify_and_install_table(), wake_from_sleep_state_hw_full(), and wake_from_sleep_state_hw_reduced().