#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>

Include dependency graph for osi.c:

Classes
struct	registered_interface

Macros
#define	WINDOWS(string, interface)

#define	HOST_FEATURE(string, type)

Functions
uacpi_status	uacpi_initialize_interfaces (void)

void	uacpi_deinitialize_interfaces (void)

uacpi_vendor_interface	uacpi_latest_queried_vendor_interface (void)

static struct registered_interface *	find_interface_unlocked (const uacpi_char *name)

static struct registered_interface *	find_host_interface_unlocked (uacpi_host_interface type)

uacpi_status	uacpi_install_interface (const uacpi_char *name, uacpi_interface_kind kind)

uacpi_status	uacpi_uninstall_interface (const uacpi_char *name)

static uacpi_status	configure_host_interface (uacpi_host_interface type, uacpi_bool enabled)

uacpi_status	uacpi_enable_host_interface (uacpi_host_interface type)

uacpi_status	uacpi_disable_host_interface (uacpi_host_interface type)

uacpi_status	uacpi_set_interface_query_handler (uacpi_interface_handler handler)

uacpi_status	uacpi_bulk_configure_interfaces (uacpi_interface_action action, uacpi_interface_kind kind)

uacpi_status	uacpi_handle_osi (const uacpi_char string, uacpi_bool out_value)

Variables
static uacpi_handle	interface_mutex

static struct registered_interface *	registered_interfaces

static uacpi_interface_handler	interface_handler

static uacpi_u32	latest_queried_interface

static struct registered_interface	predefined_interfaces []

Macro Definition Documentation

◆ HOST_FEATURE

#define HOST_FEATURE	(	string,
		type
	)

Value:

    {                                             \
        .name = string,                           \
        .weight = 0,                              \
        .kind = UACPI_INTERFACE_KIND_FEATURE,     \
        .host_type = UACPI_HOST_INTERFACE_##type, \
        .disabled = 1,                            \
        .dynamic = 0,                             \
        .next = UACPI_NULL,                       \
    }

Definition at line 42 of file osi.c.

◆ WINDOWS

#define WINDOWS	(	string,
		interface
	)

Value:

    {                                                         \
        .name = "Windows "string,                             \
        .weight = UACPI_VENDOR_INTERFACE_WINDOWS_##interface, \
        .kind = UACPI_INTERFACE_KIND_VENDOR,                  \
        .host_type = 0,                                       \
        .disabled = 0,                                        \
        .dynamic = 0,                                         \
        .next = UACPI_NULL                                    \
    }

Definition at line 31 of file osi.c.

Function Documentation

◆ configure_host_interface()

static uacpi_status configure_host_interface	(	uacpi_host_interface	type,
		uacpi_bool	enabled
	)

static

Definition at line 279 of file osi.c.

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

Referenced by uacpi_disable_host_interface(), and uacpi_enable_host_interface().

◆ find_host_interface_unlocked()

static struct registered_interface * find_host_interface_unlocked ( uacpi_host_interface type )

static

Definition at line 157 of file osi.c.

{
    struct registered_interface *interface = registered_interfaces;
 
    while (interface) {
        if (interface->host_type == type)
            return interface;
 
        interface = interface->next;
    }
 
    return UACPI_NULL;
}

◆ find_interface_unlocked()

static struct registered_interface * find_interface_unlocked ( const uacpi_char * name )

static

Definition at line 141 of file osi.c.

{
    struct registered_interface *interface = registered_interfaces;
 
    while (interface) {
        if (uacpi_strcmp(interface->name, name) == 0)
            return interface;
 
        interface = interface->next;
    }
 
    return UACPI_NULL;
}

◆ uacpi_bulk_configure_interfaces()

uacpi_status uacpi_bulk_configure_interfaces	(	uacpi_interface_action	action,
		uacpi_interface_kind	kind
	)

Bulk interface configuration, used to disable or enable all interfaces that match 'kind'.

This is generally only needed to work around buggy hardware, for example if requested from the kernel command line.

By default, all vendor strings (like "Windows 2000") are enabled, and all host features (like "3.0 Thermal Model") are disabled.

Definition at line 337 of file osi.c.

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

void uacpi_deinitialize_interfaces ( void )

Definition at line 106 of file osi.c.

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

Referenced by uacpi_state_reset().

◆ uacpi_disable_host_interface()

uacpi_status uacpi_disable_host_interface ( uacpi_host_interface type )

Definition at line 309 of file osi.c.

{
    return configure_host_interface(type, UACPI_FALSE);
}

◆ uacpi_enable_host_interface()

uacpi_status uacpi_enable_host_interface ( uacpi_host_interface type )

Same as install/uninstall interface, but comes with an enum of known interfaces defined by the ACPI specification. These are disabled by default as they depend on the host kernel support.

Definition at line 304 of file osi.c.

{
    return configure_host_interface(type, UACPI_TRUE);
}

◆ uacpi_handle_osi()

uacpi_status uacpi_handle_osi	(	const uacpi_char *	string,
		uacpi_bool *	out_value
	)

Definition at line 362 of file osi.c.

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

Referenced by uacpi_osi().

◆ uacpi_initialize_interfaces()

uacpi_status uacpi_initialize_interfaces ( void )

Definition at line 90 of file osi.c.

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

Referenced by uacpi_initialize().

◆ uacpi_install_interface()

uacpi_status uacpi_install_interface	(	const uacpi_char *	name,
		uacpi_interface_kind	kind
	)

Install or uninstall an interface.

The interface kind is used for matching during interface enumeration in uacpi_bulk_configure_interfaces().

After installing an interface, all _OSI queries report it as supported.

Definition at line 173 of file osi.c.

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

uacpi_vendor_interface uacpi_latest_queried_vendor_interface ( void )

Returns the "latest" AML-queried _OSI vendor interface.

E.g. for the following AML code: _OSI("Windows 2021") _OSI("Windows 2000")

This function will return UACPI_VENDOR_INTERFACE_WINDOWS_11, since this is the latest version of the interface the code queried, even though the "Windows 2000" query came after "Windows 2021".

Definition at line 136 of file osi.c.

{
    return uacpi_atomic_load32(&latest_queried_interface);
}

◆ uacpi_set_interface_query_handler()

uacpi_status uacpi_set_interface_query_handler ( uacpi_interface_handler handler )

Set a custom interface query (_OSI) handler.

This callback will be invoked for each _OSI query with the value passed in the _OSI, as well as whether the interface was detected as supported. The callback is able to override the return value dynamically or leave it untouched if desired (e.g. if it simply wants to log something or do internal bookkeeping of some kind).

Definition at line 314 of file osi.c.

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

uacpi_status uacpi_uninstall_interface ( const uacpi_char * name )

Definition at line 226 of file osi.c.

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