utilities.h File Reference

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

Include dependency graph for utilities.h:

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

Go to the source code of this file.

Classes
struct	uacpi_pci_routing_table_entry
struct	uacpi_pci_routing_table
struct	uacpi_id_string
struct	uacpi_pnp_id_list
struct	uacpi_namespace_node_info

Macros
#define	UACPI_NS_NODE_INFO_HAS_ADR   (1 << 0)
#define	UACPI_NS_NODE_INFO_HAS_HID   (1 << 1)
#define	UACPI_NS_NODE_INFO_HAS_UID   (1 << 2)
#define	UACPI_NS_NODE_INFO_HAS_CID   (1 << 3)
#define	UACPI_NS_NODE_INFO_HAS_CLS   (1 << 4)
#define	UACPI_NS_NODE_INFO_HAS_SXD   (1 << 5)
#define	UACPI_NS_NODE_INFO_HAS_SXW   (1 << 6)

Typedefs
typedef enum uacpi_interrupt_model	uacpi_interrupt_model
typedef struct uacpi_pci_routing_table_entry	uacpi_pci_routing_table_entry
typedef struct uacpi_pci_routing_table	uacpi_pci_routing_table
typedef struct uacpi_id_string	uacpi_id_string
typedef struct uacpi_pnp_id_list	uacpi_pnp_id_list
typedef struct uacpi_namespace_node_info	uacpi_namespace_node_info

Enumerations
enum	uacpi_interrupt_model {   UACPI_INTERRUPT_MODEL_PIC = 0 , UACPI_INTERRUPT_MODEL_IOAPIC , UACPI_INTERRUPT_MODEL_IOSAPIC , UACPI_INTERRUPT_MODEL_PLATFORM_SPECIFIC ,   UACPI_INTERRUPT_MODEL_GIC , UACPI_INTERRUPT_MODEL_LPIC , UACPI_INTERRUPT_MODEL_RINTC }

Functions
uacpi_bool	uacpi_device_matches_pnp_id (uacpi_namespace_node *node, const uacpi_char *const *list)
uacpi_status	uacpi_find_devices_at (uacpi_namespace_node *parent, const uacpi_char *const *hids, uacpi_iteration_callback cb, void *user)
uacpi_status	uacpi_find_devices (const uacpi_char *hid, uacpi_iteration_callback cb, void *user)
uacpi_status	uacpi_set_interrupt_model (uacpi_interrupt_model)
void	uacpi_free_pci_routing_table (uacpi_pci_routing_table *)
uacpi_status	uacpi_get_pci_routing_table (uacpi_namespace_node *parent, uacpi_pci_routing_table **out_table)
void	uacpi_free_id_string (uacpi_id_string *id)
uacpi_status	uacpi_eval_hid (uacpi_namespace_node *, uacpi_id_string **out_id)
void	uacpi_free_pnp_id_list (uacpi_pnp_id_list *list)
uacpi_status	uacpi_eval_cid (uacpi_namespace_node *, uacpi_pnp_id_list **out_list)
uacpi_status	uacpi_eval_sta (uacpi_namespace_node *, uacpi_u32 *flags)
uacpi_status	uacpi_eval_adr (uacpi_namespace_node *, uacpi_u64 *out)
uacpi_status	uacpi_eval_cls (uacpi_namespace_node *, uacpi_id_string **out_id)
uacpi_status	uacpi_eval_uid (uacpi_namespace_node *, uacpi_id_string **out_uid)
void	uacpi_free_namespace_node_info (uacpi_namespace_node_info *)
uacpi_status	uacpi_get_namespace_node_info (uacpi_namespace_node *node, uacpi_namespace_node_info **out_info)

Macro Definition Documentation

UACPI_NS_NODE_INFO_HAS_ADR

#define UACPI_NS_NODE_INFO_HAS_ADR   (1 << 0)

Definition at line 137 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_CID

#define UACPI_NS_NODE_INFO_HAS_CID   (1 << 3)

Definition at line 140 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_CLS

#define UACPI_NS_NODE_INFO_HAS_CLS   (1 << 4)

Definition at line 141 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_HID

#define UACPI_NS_NODE_INFO_HAS_HID   (1 << 1)

Definition at line 138 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_SXD

#define UACPI_NS_NODE_INFO_HAS_SXD   (1 << 5)

Definition at line 142 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_SXW

#define UACPI_NS_NODE_INFO_HAS_SXW   (1 << 6)

Definition at line 143 of file utilities.h.

UACPI_NS_NODE_INFO_HAS_UID

#define UACPI_NS_NODE_INFO_HAS_UID   (1 << 2)

Definition at line 139 of file utilities.h.

Typedef Documentation

uacpi_id_string

typedef struct uacpi_id_string uacpi_id_string

uacpi_interrupt_model

typedef enum uacpi_interrupt_model uacpi_interrupt_model

uacpi_namespace_node_info

typedef struct uacpi_namespace_node_info uacpi_namespace_node_info

uacpi_pci_routing_table

typedef struct uacpi_pci_routing_table uacpi_pci_routing_table

uacpi_pci_routing_table_entry

typedef struct uacpi_pci_routing_table_entry uacpi_pci_routing_table_entry

uacpi_pnp_id_list

typedef struct uacpi_pnp_id_list uacpi_pnp_id_list

Enumeration Type Documentation

uacpi_interrupt_model

enum uacpi_interrupt_model

Enumerator
UACPI_INTERRUPT_MODEL_PIC
UACPI_INTERRUPT_MODEL_IOAPIC
UACPI_INTERRUPT_MODEL_IOSAPIC
UACPI_INTERRUPT_MODEL_PLATFORM_SPECIFIC
UACPI_INTERRUPT_MODEL_GIC
UACPI_INTERRUPT_MODEL_LPIC
UACPI_INTERRUPT_MODEL_RINTC

Definition at line 48 of file utilities.h.

                                   {
    UACPI_INTERRUPT_MODEL_PIC = 0,
    UACPI_INTERRUPT_MODEL_IOAPIC,
    UACPI_INTERRUPT_MODEL_IOSAPIC,
    UACPI_INTERRUPT_MODEL_PLATFORM_SPECIFIC,
    UACPI_INTERRUPT_MODEL_GIC,
    UACPI_INTERRUPT_MODEL_LPIC,
    UACPI_INTERRUPT_MODEL_RINTC,
} uacpi_interrupt_model;

Function Documentation

uacpi_device_matches_pnp_id()

uacpi_bool uacpi_device_matches_pnp_id	(	uacpi_namespace_node *	node,
		const uacpi_char *const *	list
	)

Checks whether the device at 'node' matches any of the PNP ids provided in 'list' (terminated by a UACPI_NULL). This is done by first attempting to match the value returned from _HID and then the value(s) from _CID.

Note that the presence of the device (_STA) is not verified here.

Definition at line 905 of file utilities.c.

{
    uacpi_status st;
    uacpi_bool ret = UACPI_FALSE;
    uacpi_id_string *id = UACPI_NULL;
    uacpi_pnp_id_list *id_list = UACPI_NULL;
 
    st = uacpi_eval_hid(node, &id);
    if (st == UACPI_STATUS_OK && matches_any(id, ids)) {
        ret = UACPI_TRUE;
        goto out;
    }
 
    st = uacpi_eval_cid(node, &id_list);
    if (st == UACPI_STATUS_OK) {
        uacpi_size i;
 
        for (i = 0; i < id_list->num_ids; ++i) {
            if (matches_any(&id_list->ids[i], ids)) {
                ret = UACPI_TRUE;
                goto out;
            }
        }
    }
 
out:
    uacpi_free_id_string(id);
    uacpi_free_pnp_id_list(id_list);
    return ret;
}

Referenced by find_one_device(), and find_pci_root().

uacpi_eval_adr()

uacpi_status uacpi_eval_adr	(	uacpi_namespace_node *	node,
		uacpi_u64 *	out
	)

Evaluate a device's _ADR method and get its value.

Definition at line 600 of file utilities.c.

{
    return uacpi_eval_integer(node, "_ADR", UACPI_NULL, out);
}

Referenced by uacpi_get_namespace_node_info().

uacpi_eval_cid()

uacpi_status uacpi_eval_cid	(	uacpi_namespace_node *	node,
		uacpi_pnp_id_list **	out_list
	)

Evaluate a device's _CID method and get its value. The returned structure must be freed using uacpi_free_pnp_id_list.

Definition at line 446 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *object, *cid_ret;
    uacpi_object **objects;
    uacpi_size num_ids, i;
    uacpi_u32 size;
    uacpi_id_string *id;
    uacpi_char *id_buffer;
    uacpi_pnp_id_list *list;
 
    ret = uacpi_eval_typed(
        node, "_CID", UACPI_NULL,
        UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT |
        UACPI_OBJECT_PACKAGE_BIT,
        &cid_ret
    );
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    switch (cid_ret->type) {
    case UACPI_OBJECT_PACKAGE:
        objects = cid_ret->package->objects;
        num_ids = cid_ret->package->count;
        break;
    default:
        objects = &cid_ret;
        num_ids = 1;
        break;
    }
 
    size = sizeof(uacpi_pnp_id_list);
    size += num_ids * sizeof(uacpi_id_string);
 
    for (i = 0; i < num_ids; ++i) {
        object = objects[i];
 
        switch (object->type) {
        case UACPI_OBJECT_STRING: {
            uacpi_size buf_size = object->buffer->size;
 
            if (uacpi_unlikely(buf_size == 0)) {
                uacpi_object_name name = uacpi_namespace_node_name(node);
 
                uacpi_error(
                    "%.4s._CID: empty EISA ID string (sub-object %zu)",
                    name.text, i
                );
                return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
            }
 
            size += buf_size;
            if (uacpi_unlikely(size < buf_size)) {
                uacpi_object_name name = uacpi_namespace_node_name(node);
 
                uacpi_error(
                    "%.4s._CID: buffer size overflow (+ %zu)",
                    name.text, buf_size
                );
                return UACPI_STATUS_AML_BAD_ENCODING;
            }
 
            break;
        }
 
        case UACPI_OBJECT_INTEGER:
            size += PNP_ID_LENGTH;
            break;
        default: {
            uacpi_object_name name = uacpi_namespace_node_name(node);
 
            uacpi_error(
                "%.4s._CID: invalid package sub-object %zu type: %s",
                name.text, i,
                uacpi_object_type_to_string(object->type)
            );
            return UACPI_STATUS_AML_INCOMPATIBLE_OBJECT_TYPE;
        }
        }
    }
 
    list = uacpi_kernel_alloc(size);
    if (uacpi_unlikely(list == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
    list->num_ids = num_ids;
    list->size = size - sizeof(uacpi_pnp_id_list);
 
    id_buffer = UACPI_PTR_ADD(list, sizeof(uacpi_pnp_id_list));
    id_buffer += num_ids * sizeof(uacpi_id_string);
 
    for (i = 0; i < num_ids; ++i) {
        object = objects[i];
        id = &list->ids[i];
 
        switch (object->type) {
        case UACPI_OBJECT_STRING: {
            uacpi_buffer *buf = object->buffer;
 
            id->size = buf->size;
            id->value = id_buffer;
 
            uacpi_memcpy(id->value, buf->text, id->size);
            id->value[id->size - 1] = '\0';
            break;
        }
 
        case UACPI_OBJECT_INTEGER:
            id->size = PNP_ID_LENGTH;
            id->value = id_buffer;
            uacpi_eisa_id_to_string(object->integer, id_buffer);
            break;
        }
 
        id_buffer += id->size;
    }
 
    uacpi_object_unref(cid_ret);
    *out_list = list;
    return ret;
}

Referenced by uacpi_device_matches_pnp_id().

uacpi_eval_cls()

uacpi_status uacpi_eval_cls	(	uacpi_namespace_node *	node,
		uacpi_id_string **	out_id
	)

Evaluate a device's _CLS method and get its value. The format of returned string is BBSSPP where: BB => Base Class (e.g. 01 => Mass Storage) SS => Sub-Class (e.g. 06 => SATA) PP => Programming Interface (e.g. 01 => AHCI) The returned struture must be freed using uacpi_free_id_string.

Definition at line 621 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *obj;
    uacpi_package *pkg;
    uacpi_u8 class_codes[3];
    uacpi_id_string *id_string;
 
    ret = uacpi_eval_typed(
        node, "_CLS", UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, &obj
    );
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    pkg = obj->package;
    class_codes[0] = extract_package_byte_or_zero(pkg, 0);
    class_codes[1] = extract_package_byte_or_zero(pkg, 1);
    class_codes[2] = extract_package_byte_or_zero(pkg, 2);
 
    id_string = uacpi_kernel_alloc(sizeof(uacpi_id_string) + CLS_REPR_SIZE);
    if (uacpi_unlikely(id_string == UACPI_NULL)) {
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto out;
    }
 
    id_string->size = CLS_REPR_SIZE;
    id_string->value = UACPI_PTR_ADD(id_string, sizeof(uacpi_id_string));
 
    uacpi_snprintf(
        id_string->value, CLS_REPR_SIZE, "%02X%02X%02X",
        class_codes[0], class_codes[1], class_codes[2]
    );
 
out:
    if (uacpi_likely_success(ret))
        *out_id = id_string;
 
    uacpi_object_unref(obj);
    return ret;
}

uacpi_eval_hid()

uacpi_status uacpi_eval_hid	(	uacpi_namespace_node *	node,
		uacpi_id_string **	out_id
	)

Evaluate a device's _HID method and get its value. The returned struture must be freed using uacpi_free_id_string.

Definition at line 371 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *hid_ret;
    uacpi_id_string *id = UACPI_NULL;
    uacpi_u32 size;
 
    ret = uacpi_eval_typed(
        node, "_HID", UACPI_NULL,
        UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT,
        &hid_ret
    );
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    size = sizeof(uacpi_id_string);
 
    switch (hid_ret->type) {
    case UACPI_OBJECT_STRING: {
        uacpi_buffer *buf = hid_ret->buffer;
 
        size += buf->size;
        if (uacpi_unlikely(buf->size == 0 || size < buf->size)) {
            uacpi_object_name name = uacpi_namespace_node_name(node);
 
            uacpi_error(
                "%.4s._HID: empty/invalid EISA ID string (%zu bytes)",
                name.text, buf->size
            );
            ret = UACPI_STATUS_AML_BAD_ENCODING;
            break;
        }
 
        id = uacpi_kernel_alloc(size);
        if (uacpi_unlikely(id == UACPI_NULL)) {
            ret = UACPI_STATUS_OUT_OF_MEMORY;
            break;
        }
        id->size = buf->size;
        id->value = UACPI_PTR_ADD(id, sizeof(uacpi_id_string));
 
        uacpi_memcpy(id->value, buf->text, buf->size);
        id->value[buf->size - 1] = '\0';
        break;
    }
 
    case UACPI_OBJECT_INTEGER:
        size += PNP_ID_LENGTH;
 
        id = uacpi_kernel_alloc(size);
        if (uacpi_unlikely(id == UACPI_NULL)) {
            ret = UACPI_STATUS_OUT_OF_MEMORY;
            break;
        }
        id->size = PNP_ID_LENGTH;
        id->value = UACPI_PTR_ADD(id, sizeof(uacpi_id_string));
 
        uacpi_eisa_id_to_string(hid_ret->integer, id->value);
        break;
    }
 
    uacpi_object_unref(hid_ret);
    if (uacpi_likely_success(ret))
        *out_id = id;
    return ret;
}

Referenced by uacpi_device_matches_pnp_id().

uacpi_eval_sta()

uacpi_status uacpi_eval_sta	(	uacpi_namespace_node *	node,
		uacpi_u32 *	flags
	)

Evaluate a device's _STA method and get its value. If this method is not found, the value of 'flags' is set to all ones.

Definition at line 577 of file utilities.c.

{
    uacpi_status ret;
    uacpi_u64 value = 0;
 
    ret = uacpi_eval_integer(node, "_STA", UACPI_NULL, &value);
 
    /*
     * ACPI 6.5 specification:
     * If a device object (including the processor object) does not have
     * an _STA object, then OSPM assumes that all of the above bits are
     * set (i.e., the device is present, enabled, shown in the UI,
     * and functioning).
     */
    if (ret == UACPI_STATUS_NOT_FOUND) {
        value = 0xFFFFFFFF;
        ret = UACPI_STATUS_OK;
    }
 
    *flags = value;
    return ret;
}

Referenced by find_one_device(), and sta_eval().

uacpi_eval_uid()

uacpi_status uacpi_eval_uid	(	uacpi_namespace_node *	node,
		uacpi_id_string **	out_uid
	)

Evaluate a device's _UID method and get its value. The returned struture must be freed using uacpi_free_id_string.

Definition at line 664 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *obj;
    uacpi_id_string *id_string;
    uacpi_u32 size;
 
    ret = uacpi_eval_typed(
        node, "_UID", UACPI_NULL,
        UACPI_OBJECT_INTEGER_BIT | UACPI_OBJECT_STRING_BIT,
        &obj
    );
    if (ret != UACPI_STATUS_OK)
        return ret;
 
    if (obj->type == UACPI_OBJECT_STRING) {
        size = obj->buffer->size;
        if (uacpi_unlikely(size == 0 || size > 0xE0000000)) {
            uacpi_object_name name = uacpi_namespace_node_name(node);
 
            uacpi_error(
                "invalid %.4s._UID string size: %u",
                name.text, size
            );
            ret = UACPI_STATUS_AML_BAD_ENCODING;
            goto out;
        }
    } else {
        size = uacpi_snprintf(
            UACPI_NULL, 0, "%"UACPI_PRIu64, UACPI_FMT64(obj->integer)
        ) + 1;
    }
 
    id_string = uacpi_kernel_alloc(sizeof(uacpi_id_string) + size);
    if (uacpi_unlikely(id_string == UACPI_NULL)) {
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto out;
    }
 
    id_string->value = UACPI_PTR_ADD(id_string, sizeof(uacpi_id_string));
    id_string->size = size;
 
    if (obj->type == UACPI_OBJECT_STRING) {
        uacpi_memcpy(id_string->value, obj->buffer->text, size);
        id_string->value[size - 1] = '\0';
    } else {
        uacpi_snprintf(
            id_string->value, id_string->size, "%"UACPI_PRIu64,
            UACPI_FMT64(obj->integer)
        );
    }
 
out:
    if (uacpi_likely_success(ret))
        *out_uid = id_string;
 
    uacpi_object_unref(obj);
    return ret;
}

uacpi_find_devices()

uacpi_status uacpi_find_devices	(	const uacpi_char *	hid,
		uacpi_iteration_callback	cb,
		void *	user
	)

Same as uacpi_find_devices_at, except this starts at the root and only matches one hid.

Definition at line 986 of file utilities.c.

{
    const uacpi_char *hids[2] = {
        UACPI_NULL, UACPI_NULL
    };
 
    hids[0] = hid;
 
    return uacpi_find_devices_at(uacpi_namespace_root(), hids, cb, user);
}

uacpi_find_devices_at()

uacpi_status uacpi_find_devices_at	(	uacpi_namespace_node *	parent,
		const uacpi_char *const *	hids,
		uacpi_iteration_callback	cb,
		void *	user
	)

Find all the devices in the namespace starting at 'parent' matching the specified 'hids' (terminated by a UACPI_NULL) against any value from _HID or _CID. Only devices reported as present via _STA are checked. Any matching devices are then passed to the 'cb'.

Definition at line 967 of file utilities.c.

{
    struct device_find_ctx ctx = { 0 };
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
 
    ctx.target_hids = hids;
    ctx.user = user;
    ctx.cb = cb;
 
    return uacpi_namespace_for_each_child(
        parent, find_one_device, UACPI_NULL, UACPI_OBJECT_DEVICE_BIT,
        UACPI_MAX_DEPTH_ANY, &ctx
    );
}

Referenced by uacpi_find_devices().

uacpi_free_id_string()

void uacpi_free_id_string

(

uacpi_id_string *

id

)

Definition at line 438 of file utilities.c.

{
    if (id == UACPI_NULL)
        return;
 
    uacpi_free(id, sizeof(uacpi_id_string) + id->size);
}

Referenced by uacpi_device_matches_pnp_id(), and uacpi_get_namespace_node_info().

uacpi_free_namespace_node_info()

void uacpi_free_namespace_node_info

(

uacpi_namespace_node_info *

info

)

Definition at line 897 of file utilities.c.

{
    if (info == UACPI_NULL)
        return;
 
    uacpi_free(info, info->size);
}

uacpi_free_pci_routing_table()

void uacpi_free_pci_routing_table

(

uacpi_pci_routing_table *

table

)

Definition at line 1136 of file utilities.c.

{
    if (table == UACPI_NULL)
        return;
 
    uacpi_free(
        table,
        sizeof(uacpi_pci_routing_table) +
        table->num_entries * sizeof(uacpi_pci_routing_table_entry)
    );
}

Referenced by uacpi_get_pci_routing_table().

uacpi_free_pnp_id_list()

void uacpi_free_pnp_id_list

(

uacpi_pnp_id_list *

list

)

Definition at line 569 of file utilities.c.

{
    if (list == UACPI_NULL)
        return;
 
    uacpi_free(list, sizeof(uacpi_pnp_id_list) + list->size);
}

Referenced by uacpi_device_matches_pnp_id(), and uacpi_get_namespace_node_info().

uacpi_get_namespace_node_info()

uacpi_status uacpi_get_namespace_node_info	(	uacpi_namespace_node *	node,
		uacpi_namespace_node_info **	out_info
	)

Retrieve information about a namespace node. This includes the attached object's type, name, number of parameters (if it's a method), the result of evaluating _ADR, _UID, _CLS, _HID, _CID, as well as _SxD and _SxW.

The returned structure must be freed with uacpi_free_namespace_node_info.

Definition at line 797 of file utilities.c.

{
    uacpi_status ret = UACPI_STATUS_OK;
    uacpi_u32 size = sizeof(uacpi_namespace_node_info);
    uacpi_object *obj;
    uacpi_namespace_node_info *info;
    uacpi_id_string *hid = UACPI_NULL, *uid = UACPI_NULL, *cls = UACPI_NULL;
    uacpi_pnp_id_list *cid = UACPI_NULL;
    uacpi_char *cursor;
    uacpi_u64 adr = 0;
    uacpi_u8 flags = 0;
    uacpi_u8 sxd[4], sxw[5];
 
    obj = uacpi_namespace_node_get_object(node);
    if (uacpi_unlikely(obj == UACPI_NULL))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    if (obj->type == UACPI_OBJECT_DEVICE ||
        obj->type == UACPI_OBJECT_PROCESSOR) {
        char dstate_method_template[5] = { '_', 'S', '1', 'D', '\0' };
 
        NODE_INFO_EVAL_ADD_ID(hid)
        NODE_INFO_EVAL_ADD_ID(uid)
        NODE_INFO_EVAL_ADD_ID(cls)
        NODE_INFO_EVAL_ADD_ID(cid)
 
        if (uacpi_eval_adr(node, &adr) == UACPI_STATUS_OK)
            flags |= UACPI_NS_NODE_INFO_HAS_ADR;
 
        if (uacpi_eval_dstate_method_template(
                node, dstate_method_template, sizeof(sxd), sxd
            ) == UACPI_STATUS_OK)
            flags |= UACPI_NS_NODE_INFO_HAS_SXD;
 
        dstate_method_template[2] = '0';
        dstate_method_template[3] = 'W';
 
        if (uacpi_eval_dstate_method_template(
                node, dstate_method_template, sizeof(sxw), sxw
            ) == UACPI_STATUS_OK)
            flags |= UACPI_NS_NODE_INFO_HAS_SXW;
    }
 
    info = uacpi_kernel_alloc(size);
    if (uacpi_unlikely(info == UACPI_NULL)) {
        ret = UACPI_STATUS_OUT_OF_MEMORY;
        goto out;
    }
    info->size = size;
    cursor = UACPI_PTR_ADD(info, sizeof(uacpi_namespace_node_info));
    info->name = uacpi_namespace_node_name(node);
    info->type = obj->type;
    info->num_params = info->type == UACPI_OBJECT_METHOD ? obj->method->args : 0;
 
    info->adr = adr;
    if (flags & UACPI_NS_NODE_INFO_HAS_SXD)
        uacpi_memcpy(info->sxd, sxd, sizeof(sxd));
    else
        uacpi_memzero(info->sxd, sizeof(info->sxd));
 
    if (flags & UACPI_NS_NODE_INFO_HAS_SXW)
        uacpi_memcpy(info->sxw, sxw, sizeof(sxw));
    else
        uacpi_memzero(info->sxw, sizeof(info->sxw));
 
    if (cid != UACPI_NULL) {
        uacpi_u32 i;
 
        uacpi_memcpy(&info->cid, cid, cid->size + sizeof(*cid));
        cursor += cid->num_ids * sizeof(uacpi_id_string);
 
        for (i = 0; i < cid->num_ids; ++i) {
            info->cid.ids[i].value = cursor;
            cursor += info->cid.ids[i].size;
        }
 
        flags |= UACPI_NS_NODE_INFO_HAS_CID;
    } else {
        uacpi_memzero(&info->cid, sizeof(*cid));
    }
 
    NODE_INFO_COPY_ID(hid, HID)
    NODE_INFO_COPY_ID(uid, UID)
    NODE_INFO_COPY_ID(cls, CLS)
 
out:
    if (uacpi_likely_success(ret)) {
        info->flags = flags;
        *out_info = info;
    }
 
    uacpi_free_id_string(hid);
    uacpi_free_id_string(uid);
    uacpi_free_id_string(cls);
    uacpi_free_pnp_id_list(cid);
    return ret;
}

uacpi_get_pci_routing_table()

uacpi_status uacpi_get_pci_routing_table	(	uacpi_namespace_node *	parent,
		uacpi_pci_routing_table **	out_table
	)

Definition at line 1024 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *obj, *entry_obj, *elem_obj;
    uacpi_package *table_pkg, *entry_pkg;
    uacpi_pci_routing_table_entry *entry;
    uacpi_pci_routing_table *table;
    uacpi_size size, i;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
 
    obj = uacpi_namespace_node_get_object(parent);
    if (uacpi_unlikely(obj == UACPI_NULL || obj->type != UACPI_OBJECT_DEVICE))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    ret = uacpi_eval_typed(
        parent, "_PRT", UACPI_NULL, UACPI_OBJECT_PACKAGE_BIT, &obj
    );
    if (uacpi_unlikely_error(ret))
        return ret;
 
    table_pkg = obj->package;
    if (uacpi_unlikely(table_pkg->count == 0 || table_pkg->count > 1024)) {
        uacpi_error("invalid number of _PRT entries: %zu", table_pkg->count);
        uacpi_object_unref(obj);
        return UACPI_STATUS_AML_BAD_ENCODING;
    }
 
    size = table_pkg->count * sizeof(uacpi_pci_routing_table_entry);
    table = uacpi_kernel_alloc(sizeof(uacpi_pci_routing_table) + size);
    if (uacpi_unlikely(table == UACPI_NULL)) {
        uacpi_object_unref(obj);
        return UACPI_STATUS_OUT_OF_MEMORY;
    }
    table->num_entries = table_pkg->count;
 
    for (i = 0; i < table_pkg->count; ++i) {
        entry_obj = table_pkg->objects[i];
 
        if (uacpi_unlikely(entry_obj->type != UACPI_OBJECT_PACKAGE)) {
            uacpi_error("_PRT sub-object %zu is not a package: %s",
                        i, uacpi_object_type_to_string(entry_obj->type));
            goto out_bad_encoding;
        }
 
        entry_pkg = entry_obj->package;
        if (uacpi_unlikely(entry_pkg->count != 4)) {
            uacpi_error("invalid _PRT sub-package entry count %zu",
                        entry_pkg->count);
            goto out_bad_encoding;
        }
 
        entry = &table->entries[i];
 
        elem_obj = entry_pkg->objects[0];
        if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
            uacpi_error("invalid _PRT sub-package %zu address type: %s",
                        i, uacpi_object_type_to_string(elem_obj->type));
            goto out_bad_encoding;
        }
        entry->address = elem_obj->integer;
 
        elem_obj = entry_pkg->objects[1];
        if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
            uacpi_error("invalid _PRT sub-package %zu pin type: %s",
                        i, uacpi_object_type_to_string(elem_obj->type));
            goto out_bad_encoding;
        }
        entry->pin = elem_obj->integer;
 
        elem_obj = entry_pkg->objects[2];
        switch (elem_obj->type) {
        case UACPI_OBJECT_STRING:
            ret = uacpi_object_resolve_as_aml_namepath(
                elem_obj, parent, &entry->source
            );
            if (uacpi_unlikely_error(ret)) {
                uacpi_error("unable to lookup _PRT source %s: %s",
                            elem_obj->buffer->text, uacpi_status_to_string(ret));
                goto out_bad_encoding;
            }
            break;
        case UACPI_OBJECT_INTEGER:
            entry->source = UACPI_NULL;
            break;
        default:
            uacpi_error("invalid _PRT sub-package %zu source type: %s",
                        i, uacpi_object_type_to_string(elem_obj->type));
            goto out_bad_encoding;
        }
 
        elem_obj = entry_pkg->objects[3];
        if (uacpi_unlikely(elem_obj->type != UACPI_OBJECT_INTEGER)) {
            uacpi_error("invalid _PRT sub-package %zu source index type: %s",
                        i, uacpi_object_type_to_string(elem_obj->type));
            goto out_bad_encoding;
        }
        entry->index = elem_obj->integer;
    }
 
    uacpi_object_unref(obj);
    *out_table = table;
    return UACPI_STATUS_OK;
 
out_bad_encoding:
    uacpi_object_unref(obj);
    uacpi_free_pci_routing_table(table);
    return UACPI_STATUS_AML_BAD_ENCODING;
}

uacpi_set_interrupt_model()

uacpi_status uacpi_set_interrupt_model

(

uacpi_interrupt_model

model

)

Definition at line 999 of file utilities.c.

{
    uacpi_status ret;
    uacpi_object *arg;
    uacpi_object_array args;
 
    UACPI_ENSURE_INIT_LEVEL_AT_LEAST(UACPI_INIT_LEVEL_NAMESPACE_LOADED);
 
    arg = uacpi_create_object(UACPI_OBJECT_INTEGER);
    if (uacpi_unlikely(arg == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    arg->integer = model;
    args.objects = &arg;
    args.count = 1;
 
    ret = uacpi_eval(uacpi_namespace_root(), "_PIC", &args, UACPI_NULL);
    uacpi_object_unref(arg);
 
    if (ret == UACPI_STATUS_NOT_FOUND)
        ret = UACPI_STATUS_OK;
 
    return ret;
}