opregion.h File Reference

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

Include dependency graph for opregion.h:

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

Go to the source code of this file.

Functions
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)
uacpi_status	uacpi_uninstall_address_space_handler (uacpi_namespace_node *device_node, enum uacpi_address_space space)
uacpi_status	uacpi_reg_all_opregions (uacpi_namespace_node *device_node, enum uacpi_address_space space)

Function Documentation

uacpi_install_address_space_handler()

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
	)

Install an address space handler to a device node. The handler is recursively connected to all of the operation regions of type 'space' underneath 'device_node'. Note that this recursion stops as soon as another device node that already has an address space handler of this type installed is encountered.

Definition at line 706 of file opregion.c.

{
    return uacpi_install_address_space_handler_with_flags(
        device_node, space, handler, handler_context, 0
    );
}

uacpi_reg_all_opregions()

uacpi_status uacpi_reg_all_opregions	(	uacpi_namespace_node *	device_node,
		enum uacpi_address_space	space
	)

Execute _REG(space, ACPI_REG_CONNECT) for all of the opregions with this address space underneath this device. This should only be called manually if you want to register an early handler that must be available before the call to uacpi_namespace_initialize().

Definition at line 590 of file opregion.c.

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

Referenced by uacpi_namespace_initialize().

uacpi_uninstall_address_space_handler()

uacpi_status uacpi_uninstall_address_space_handler	(	uacpi_namespace_node *	device_node,
		enum uacpi_address_space	space
	)

Uninstall the handler of type 'space' from a given device node.

Definition at line 716 of file opregion.c.

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