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_region_handler handler)
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 977 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 847 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_all_opregions(device_node, space);
 
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,
		uacpi_region_handler	handler
	)

Uninstall a handler of type 'space' previously installed to a device node.

'handler' must be the handler that is currently installed there, otherwise nothing is uninstalled, and UACPI_STATUS_INVALID_ARGUMENT is returned. This makes sure that a handler that was installed by somebody else in the meantime is not uninstalled by mistake.

Definition at line 987 of file opregion.c.

{
    uacpi_status ret;
    uacpi_address_space_handlers *handlers;
    uacpi_address_space_handler *this_handler, *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;
    }
 
    this_handler = find_handler(handlers, space);
    if (uacpi_unlikely(this_handler == UACPI_NULL)) {
        ret = UACPI_STATUS_NO_HANDLER;
        goto out;
    }
 
    // This is somebody else's handler, and is thus not ours to uninstall
    if (uacpi_unlikely(this_handler->callback != handler)) {
        ret = UACPI_STATUS_INVALID_ARGUMENT;
        goto out;
    }
 
    /*
     * Both the handler and the _REG methods are invoked as the regions are
     * taken away below, and are free to do whatever they want in response.
     * Make sure that the handler is no longer there to be found by then, be
     * it by a region that is created in the meantime, or by the handler
     * itself in case it decides to uninstall itself as it's told to detach
     * a region. The reference that the device had is now ours, which is what
     * keeps the handler alive until we're done.
     */
    prev_handler = handlers->head;
 
    // Are we the last linked handler?
    if (prev_handler == this_handler) {
        handlers->head = this_handler->next;
    } else {
        // Nope, we're somewhere in the middle. Do a search.
        while (prev_handler->next != this_handler)
            prev_handler = prev_handler->next;
 
        prev_handler->next = this_handler->next;
    }
 
    iter_ctx.handler = this_handler;
    iter_ctx.handlers = handlers;
    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
    );
 
    uacpi_address_space_handler_unref(this_handler);
 
out:
    uacpi_namespace_write_unlock();
    uacpi_recursive_lock_release(&g_opregion_lock);
    return ret;
}