#include <uacpi/types.h>
#include <uacpi/acpi.h>
#include <uacpi/internal/resources.h>
#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/utilities.h>
#include <uacpi/internal/log.h>
#include <uacpi/internal/namespace.h>
#include <uacpi/uacpi.h>

Include dependency graph for resources.c:

Classes
struct	resource_conversion_ctx

Macros
#define	LARGE_RESOURCE_BASE (ACPI_RESOURCE_END_TAG + 1)

#define	L(x) (x + LARGE_RESOURCE_BASE)

#define	SMALL_ITEM_HEADER_SIZE sizeof(struct acpi_small_item)

#define	LARGE_ITEM_HEADER_SIZE sizeof(struct acpi_large_item)

#define	AML_SERIAL_RESOURCE_EXTRA_SIZE(type)

#define	NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(type)

#define	OP(short_code, ...)

#define	END() OP(END)

#define	AML_O(short_aml_name, field) uacpi_offsetof(struct acpi_resource_##short_aml_name, field)

#define	AML_F(short_aml_name, field) .aml_offset = AML_O(short_aml_name, field)

#define	NATIVE_O(short_name, field) uacpi_offsetof(uacpi_resource_##short_name, field)

#define	NATIVE_F(short_native_name, field) .native_offset = NATIVE_O(short_native_name, field)

#define	IMM(value) .imm = value

#define	ARG0(value) .arg0 = (value)

#define	ARG1(value) .arg1 = (value)

#define	ARG2(value) .arg2 = (value)

#define	CONVERT_TYPE_SPECIFIC_FLAGS(addr_type)

#define	CONVERT_GENERAL_ADDRESS_FLAGS(addr_type)

#define	DEFINE_ADDRESS_CONVERSION(width)

#define	DECODE_SOURCE_INDEX(short_aml_name)

#define	DECODE_RES_PIN_TBL_AND_VENDOR_DATA( short_aml_name, res_opcode, offset_field, res_field)

#define	DECODE_PIN_GROUP_RES_SOURCES(postfix)

#define	NATIVE_RESOURCE_HEADER_SIZE 8

#define	DEFINE_SMALL_AML_RESOURCE(aml_type_enum, native_type_enum, aml_struct, native_struct, ...)

#define	DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR( aml_type_enum, native_type_enum, aml_struct, ...)

#define	DEFINE_LARGE_AML_RESOURCE(aml_type_enum, native_type_enum, aml_struct, native_struct, ...)

#define	CONVERSION_OPCODES_COMMON(native_buf)

#define	PTR_AT(ptr, offset) (void)((uacpi_u8)(ptr) + (offset))

#define	NATIVE_OFFSET(res, offset) PTR_AT(res, (offset) + (sizeof(uacpi_u32) * 2))

#define	NATIVE_FIELD(res, name, field) NATIVE_OFFSET(res, NATIVE_O(name, field))

#define	CHECK_AML_OOB(offset, prefix, what)

#define	CHECK_AML_OFFSET_BASE(offset, what)

#define	CHECK_AML_OFFSET(offset, what)

#define	INLINE_END_TAG &(uacpi_resource) { .type = UACPI_RESOURCE_TYPE_END_TAG }

Functions
static uacpi_size	aml_size_with_header (const struct uacpi_resource_spec *spec)

static uacpi_size	extra_size_for_native_irq_or_dma (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_irq (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	size_for_aml_start_dependent (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_native_vendor (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_vendor (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_resource_source (uacpi_size base_size, uacpi_size reported_size)

static uacpi_size	size_for_aml_resource_source (uacpi_resource_source *source, uacpi_bool with_index)

static uacpi_size	extra_size_for_native_address_or_clock_input (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_address_or_clock_input (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_extended_irq (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_extended_irq (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_native_gpio_or_pins (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_gpio_or_pins (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_native_pin_group (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	size_for_aml_pin_group (const struct uacpi_resource_spec spec, uacpi_resource resource)

static uacpi_size	extra_size_for_serial_connection (const struct uacpi_resource_spec spec, void data, uacpi_size size)

static uacpi_size	aml_size_for_serial_connection (const struct uacpi_resource_spec spec, uacpi_resource resource)

static enum uacpi_aml_resource	get_aml_resource_type (uacpi_u8 raw_byte)

static uacpi_status	get_aml_resource_size (uacpi_u8 data, uacpi_size bytes_left, uacpi_u16 out_size)

static uacpi_status	validate_aml_serial_type (uacpi_u8 type)

uacpi_status	uacpi_for_each_aml_resource (uacpi_data_view buffer, uacpi_aml_resource_iteration_callback cb, void *user)

static uacpi_iteration_decision	find_end (void opaque, uacpi_u8 data, uacpi_u16 resource_size, const struct uacpi_resource_spec *spec)

static uacpi_size	native_size_for_aml_resource (uacpi_u8 data, uacpi_u16 size, const struct uacpi_resource_spec spec)

uacpi_status	uacpi_find_aml_resource_end_tag (uacpi_data_view buffer, uacpi_size *out_offset)

static uacpi_iteration_decision	conditional_continue (struct resource_conversion_ctx *ctx)

static uacpi_resource_type	aml_serial_to_native_type (uacpi_u8 type)

static uacpi_iteration_decision	do_aml_resource_to_native (void opaque, uacpi_u8 data, uacpi_u16 aml_size, const struct uacpi_resource_spec *spec)

static uacpi_iteration_decision	accumulate_native_buffer_size (void opaque, uacpi_u8 data, uacpi_u16 resource_size, const struct uacpi_resource_spec *spec)

static uacpi_status	eval_resource_helper (uacpi_namespace_node node, const uacpi_char method, uacpi_object **out_obj)

uacpi_status	uacpi_native_resources_from_aml (uacpi_data_view aml_buffer, uacpi_resources **out_resources)

uacpi_status	uacpi_get_resource_from_buffer (uacpi_data_view aml_buffer, uacpi_resource **out_resource)

void	uacpi_free_resources (uacpi_resources *resources)

void	uacpi_free_resource (uacpi_resource *resource)

static uacpi_status	extract_native_resources_from_method (uacpi_namespace_node device, const uacpi_char method, uacpi_resources **out_resources)

uacpi_status	uacpi_get_current_resources (uacpi_namespace_node device, uacpi_resources *out_resources)

uacpi_status	uacpi_get_possible_resources (uacpi_namespace_node device, uacpi_resources *out_resources)

uacpi_status	uacpi_get_device_resources (uacpi_namespace_node device, const uacpi_char method, uacpi_resources **out_resources)

uacpi_status	uacpi_for_each_resource (uacpi_resources resources, uacpi_resource_iteration_callback cb, void user)

uacpi_status	uacpi_for_each_device_resource (uacpi_namespace_node device, const uacpi_char method, uacpi_resource_iteration_callback cb, void *user)

static const struct uacpi_resource_spec *	resource_spec_from_native (uacpi_resource *resource)

static uacpi_size	aml_size_for_native_resource (uacpi_resource resource, const struct uacpi_resource_spec spec)

static uacpi_iteration_decision	do_native_resource_to_aml (void opaque, uacpi_resource resource)

static uacpi_status	native_resources_to_aml (uacpi_resources native_resources, void aml_buffer)

static uacpi_iteration_decision	accumulate_aml_buffer_size (void opaque, uacpi_resource resource)

uacpi_status	uacpi_native_resources_to_aml (uacpi_resources resources, uacpi_object *out_template)

uacpi_status	uacpi_set_resources (uacpi_namespace_node device, uacpi_resources resources)

Variables
static const uacpi_u8	aml_resource_to_type [256]

static const uacpi_u8	type_to_aml_resource []

static const uacpi_u8	native_resource_to_type [UACPI_RESOURCE_TYPE_MAX+1]

static const uacpi_u8	aml_resource_kind_to_header_size [2]

static const uacpi_u8	aml_serial_resource_to_extra_aml_size [ACPI_SERIAL_TYPE_MAX+1]

static const uacpi_u8	aml_serial_resource_to_extra_native_size [ACPI_SERIAL_TYPE_MAX+1]

static const struct uacpi_resource_convert_instruction	convert_irq_to_native []

const struct uacpi_resource_convert_instruction	convert_irq_to_aml []

static const struct uacpi_resource_convert_instruction	convert_dma []

static const struct uacpi_resource_convert_instruction	convert_start_dependent_to_native []

static const struct uacpi_resource_convert_instruction	convert_start_dependent_to_aml []

static const struct uacpi_resource_convert_instruction	convert_io []

static const struct uacpi_resource_convert_instruction	convert_fixed_io []

static const struct uacpi_resource_convert_instruction	convert_fixed_dma []

static const struct uacpi_resource_convert_instruction	convert_vendor_type0 []

static const struct uacpi_resource_convert_instruction	convert_vendor_type1 []

static const struct uacpi_resource_convert_instruction	convert_memory24 []

static const struct uacpi_resource_convert_instruction	convert_memory32 []

static const struct uacpi_resource_convert_instruction	convert_fixed_memory32 []

static const struct uacpi_resource_convert_instruction	convert_generic_register []

static const struct uacpi_resource_convert_instruction	convert_address64_extended []

static const struct uacpi_resource_convert_instruction	convert_extended_irq []

static const struct uacpi_resource_convert_instruction	convert_clock_input []

static const struct uacpi_resource_convert_instruction	convert_gpio_connection []

static const struct uacpi_resource_convert_instruction	convert_pin_function []

static const struct uacpi_resource_convert_instruction	convert_pin_configuration []

static const struct uacpi_resource_convert_instruction	convert_pin_group []

static const struct uacpi_resource_convert_instruction	convert_pin_group_function []

static const struct uacpi_resource_convert_instruction	convert_pin_group_configuration []

static const struct uacpi_resource_convert_instruction	convert_generic_serial_bus []

const struct uacpi_resource_spec	aml_resources [UACPI_AML_RESOURCE_MAX+1]

Macro Definition Documentation

◆ AML_F

#define AML_F	(	short_aml_name,
		field
	)	.aml_offset = AML_O(short_aml_name, field)

Definition at line 589 of file resources.c.

◆ AML_O

#define AML_O	(	short_aml_name,
		field
	)	uacpi_offsetof(struct acpi_resource_##short_aml_name, field)

Definition at line 586 of file resources.c.

◆ AML_SERIAL_RESOURCE_EXTRA_SIZE

#define AML_SERIAL_RESOURCE_EXTRA_SIZE ( type )

Value:

(sizeof(struct acpi_resource_serial_##type) \

- sizeof(struct acpi_resource_serial))

type

GLuint GLuint GLsizei GLenum type

Definition: gl.h:1545

struct

Definition: axextend.idl:118

sizeof

ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList

Definition at line 525 of file resources.c.

◆ ARG0

#define ARG0 ( value ) .arg0 = (value)

Definition at line 599 of file resources.c.

◆ ARG1

#define ARG1 ( value ) .arg1 = (value)

Definition at line 600 of file resources.c.

◆ ARG2

#define ARG2 ( value ) .arg2 = (value)

Definition at line 601 of file resources.c.

◆ CHECK_AML_OFFSET

#define CHECK_AML_OFFSET	(	offset,
		what
	)

Value:

CHECK_AML_OOB(offset, "end of ", what) \

CHECK_AML_OFFSET_BASE(offset, what)

CHECK_AML_OOB

#define CHECK_AML_OOB(offset, prefix, what)

Definition: resources.c:1644

offset

GLintptr offset

Definition: glext.h:5920

Definition at line 1661 of file resources.c.

◆ CHECK_AML_OFFSET_BASE

#define CHECK_AML_OFFSET_BASE	(	offset,
		what
	)

Value:

    if (uacpi_unlikely(offset < base_aml_size_with_header)) {           \
        uacpi_error(                                                    \
            "invalid " what " offset: %zu, expected at least %u\n",     \
            (uacpi_size)offset, base_aml_size_with_header);             \
        ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;                    \
        return UACPI_ITERATION_DECISION_BREAK;                          \
    }

Definition at line 1652 of file resources.c.

◆ CHECK_AML_OOB

#define CHECK_AML_OOB	(	offset,
		prefix,
		what
	)

Value:

    if (uacpi_unlikely(offset > ((uacpi_u32)aml_size + header_size))) {      \
        uacpi_error(prefix what " is OOB: %zu > %u\n",                       \
                    (uacpi_size)offset, (uacpi_u32)aml_size + header_size);  \
        ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;                         \
        return UACPI_ITERATION_DECISION_BREAK;                               \
    }

Definition at line 1644 of file resources.c.

◆ CONVERSION_OPCODES_COMMON

#define CONVERSION_OPCODES_COMMON ( native_buf )

Definition at line 1570 of file resources.c.

◆ CONVERT_GENERAL_ADDRESS_FLAGS

#define CONVERT_GENERAL_ADDRESS_FLAGS ( addr_type )

Value:

    OP(BIT_FIELD_1,                                            \
       AML_F(addr_type, common.flags),                         \
       NATIVE_F(addr_type, common.direction), IMM(0)),         \
    OP(BIT_FIELD_1,                                            \
       AML_F(addr_type, common.flags),                         \
       NATIVE_F(addr_type, common.decode_type), IMM(1)),       \
    OP(BIT_FIELD_1,                                            \
       AML_F(addr_type, common.flags),                         \
       NATIVE_F(addr_type, common.fixed_min_address), IMM(2)), \
    OP(BIT_FIELD_1,                                            \
      AML_F(addr_type, common.flags),                          \
      NATIVE_F(addr_type, common.fixed_max_address), IMM(3))   \

Definition at line 773 of file resources.c.

◆ CONVERT_TYPE_SPECIFIC_FLAGS

#define CONVERT_TYPE_SPECIFIC_FLAGS ( addr_type )

Definition at line 740 of file resources.c.

◆ DECODE_PIN_GROUP_RES_SOURCES

#define DECODE_PIN_GROUP_RES_SOURCES ( postfix )

Value:

    DECODE_SOURCE_INDEX(pin_group_##postfix),                           \
    OP(RESOURCE_SOURCE_NO_INDEX, NATIVE_F(pin_group_##postfix, source), \
       AML_F(pin_group_##postfix, source_offset),                       \
       ARG2(AML_O(pin_group_##postfix, source_lable_offset))),          \
    OP(LOAD_16_NATIVE, NATIVE_F(pin_group_##postfix, source.length)),   \
    OP(RESOURCE_LABEL, NATIVE_F(pin_group_##postfix, label),            \
       AML_F(pin_group_##postfix, source_lable_offset),                 \
       ARG2(AML_O(pin_group_##postfix, vendor_data_offset))),           \
    OP(VENDOR_DATA, AML_F(pin_group_##postfix, vendor_data_offset),     \
       NATIVE_F(pin_group_##postfix, vendor_data_length),               \
       ARG2(NATIVE_O(pin_group_##postfix, vendor_data)))

Definition at line 948 of file resources.c.

◆ DECODE_RES_PIN_TBL_AND_VENDOR_DATA

#define DECODE_RES_PIN_TBL_AND_VENDOR_DATA	(	short_aml_name,
		res_opcode,
		offset_field,
		res_field
	)

Value:

    OP(LOAD_PIN_TABLE_LENGTH, AML_F(short_aml_name, offset_field),     \
       NATIVE_F(short_aml_name, pin_table_length)),                    \
    OP(RESOURCE_##res_opcode, NATIVE_F(short_aml_name, res_field),     \
       AML_F(short_aml_name, offset_field),                            \
       ARG2(AML_O(short_aml_name, vendor_data_offset))),               \
    OP(PIN_TABLE, AML_F(short_aml_name, pin_table_offset),             \
       NATIVE_F(short_aml_name, pin_table_length),                     \
       ARG2(NATIVE_O(short_aml_name, pin_table))),                     \
    OP(VENDOR_DATA, AML_F(short_aml_name, vendor_data_offset),         \
       NATIVE_F(short_aml_name, vendor_data_length),                   \
       ARG2(NATIVE_O(short_aml_name, vendor_data)))

Definition at line 850 of file resources.c.

◆ DECODE_SOURCE_INDEX

#define DECODE_SOURCE_INDEX ( short_aml_name )

Value:

OP(FIELD_8, AML_F(short_aml_name, source_index), \

NATIVE_F(short_aml_name, source.index)) \

source::index

DWORD index

Definition: pdh_main.c:175

Definition at line 846 of file resources.c.

◆ DEFINE_ADDRESS_CONVERSION

#define DEFINE_ADDRESS_CONVERSION ( width )

Value:

    static const struct uacpi_resource_convert_instruction            \
    convert_address##width[] = {                                      \
        CONVERT_GENERAL_ADDRESS_FLAGS(address##width),                \
        OP(FIELD_##width, AML_F(address##width, granularity),         \
           NATIVE_F(address##width, granularity), IMM(5)),            \
        OP(RESOURCE_SOURCE, NATIVE_F(address##width, source)),        \
        CONVERT_TYPE_SPECIFIC_FLAGS(address##width),                  \
    };

Definition at line 787 of file resources.c.

◆ DEFINE_LARGE_AML_RESOURCE

#define DEFINE_LARGE_AML_RESOURCE	(	aml_type_enum,
		native_type_enum,
		aml_struct,
		native_struct,
		...
	)

Value:

    [aml_type_enum] = {                                                      \
        .type = aml_type_enum,                                               \
        .native_type = native_type_enum,                                     \
        .resource_kind = UACPI_AML_RESOURCE_KIND_LARGE,                      \
        .aml_size = sizeof(aml_struct) - LARGE_ITEM_HEADER_SIZE,             \
        .native_size = sizeof(native_struct) + NATIVE_RESOURCE_HEADER_SIZE,  \
        __VA_ARGS__                                                          \
    }

Definition at line 1084 of file resources.c.

◆ DEFINE_SMALL_AML_RESOURCE

#define DEFINE_SMALL_AML_RESOURCE	(	aml_type_enum,
		native_type_enum,
		aml_struct,
		native_struct,
		...
	)

Value:

    [aml_type_enum] = {                                                      \
        .type = aml_type_enum,                                               \
        .native_type = native_type_enum,                                     \
        .resource_kind = UACPI_AML_RESOURCE_KIND_SMALL,                      \
        .aml_size = sizeof(aml_struct) - SMALL_ITEM_HEADER_SIZE,             \
        .native_size = sizeof(native_struct) + NATIVE_RESOURCE_HEADER_SIZE,  \
        __VA_ARGS__                                                          \
    }

Definition at line 1061 of file resources.c.

◆ DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR

#define DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR	(	aml_type_enum,
		native_type_enum,
		aml_struct,
		...
	)

Value:

    [aml_type_enum] = {                                          \
        .type = aml_type_enum,                                   \
        .native_type = native_type_enum,                         \
        .resource_kind = UACPI_AML_RESOURCE_KIND_SMALL,          \
        .aml_size = sizeof(aml_struct) - SMALL_ITEM_HEADER_SIZE, \
        .native_size = NATIVE_RESOURCE_HEADER_SIZE,              \
        __VA_ARGS__                                              \
    }

Definition at line 1072 of file resources.c.

◆ END

#define END ( ) OP(END)

Definition at line 584 of file resources.c.

◆ IMM

#define IMM ( value ) .imm = value

Definition at line 598 of file resources.c.

◆ INLINE_END_TAG

#define INLINE_END_TAG &(uacpi_resource) { .type = UACPI_RESOURCE_TYPE_END_TAG }

Definition at line 2443 of file resources.c.

◆ L

#define L ( x ) (x + LARGE_RESOURCE_BASE)

Examples: /srv/doxygen/reactos/win32ss/gdi/gdi32/objects/utils.c.

Definition at line 13 of file resources.c.

◆ LARGE_ITEM_HEADER_SIZE

#define LARGE_ITEM_HEADER_SIZE sizeof(struct acpi_large_item)

Definition at line 118 of file resources.c.

◆ LARGE_RESOURCE_BASE

#define LARGE_RESOURCE_BASE (ACPI_RESOURCE_END_TAG + 1)

Definition at line 12 of file resources.c.

◆ NATIVE_F

#define NATIVE_F	(	short_native_name,
		field
	)	.native_offset = NATIVE_O(short_native_name, field)

Definition at line 595 of file resources.c.

◆ NATIVE_FIELD

#define NATIVE_FIELD	(	res,
		name,
		field
	)	NATIVE_OFFSET(res, NATIVE_O(name, field))

Definition at line 1641 of file resources.c.

◆ NATIVE_O

#define NATIVE_O	(	short_name,
		field
	)	uacpi_offsetof(uacpi_resource_##short_name, field)

Definition at line 592 of file resources.c.

◆ NATIVE_OFFSET

#define NATIVE_OFFSET	(	res,
		offset
	)	PTR_AT(res, (offset) + (sizeof(uacpi_u32) * 2))

Definition at line 1638 of file resources.c.

◆ NATIVE_RESOURCE_HEADER_SIZE

#define NATIVE_RESOURCE_HEADER_SIZE 8

Definition at line 1059 of file resources.c.

◆ NATIVE_SERIAL_RESOURCE_EXTRA_SIZE

#define NATIVE_SERIAL_RESOURCE_EXTRA_SIZE ( type )

Value:

(sizeof(uacpi_resource_##type##_connection) \

- sizeof(uacpi_resource_serial_bus_common))

uacpi_resource_serial_bus_common

Definition: resources.h:396

Definition at line 529 of file resources.c.

◆ OP

#define OP	(	short_code,
		...
	)

Value:

{                                                       \
    .code = UACPI_RESOURCE_CONVERT_OPCODE_##short_code, \
    __VA_ARGS__                                         \
}

Definition at line 578 of file resources.c.

◆ PTR_AT

#define PTR_AT	(	ptr,
		offset
	)	(void)((uacpi_u8)(ptr) + (offset))

Definition at line 1636 of file resources.c.

◆ SMALL_ITEM_HEADER_SIZE

#define SMALL_ITEM_HEADER_SIZE sizeof(struct acpi_small_item)

Definition at line 117 of file resources.c.

Function Documentation

◆ accumulate_aml_buffer_size()

static uacpi_iteration_decision accumulate_aml_buffer_size	(	void *	opaque,
		uacpi_resource *	resource
	)

static

Definition at line 2468 of file resources.c.

{
    struct resource_conversion_ctx *ctx = opaque;
    const struct uacpi_resource_spec *spec;
    uacpi_size size_for_this;
 
    // resource->type is sanitized to be valid here by the iteration function
    spec = resource_spec_from_native(resource);
 
    size_for_this = aml_size_for_native_resource(resource, spec);
    if (size_for_this == 0 || (ctx->size + size_for_this) < ctx->size) {
        uacpi_error("invalid aml size for native resource: %zu\n",
                    size_for_this);
        ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
        return UACPI_ITERATION_DECISION_BREAK;
    }
 
    ctx->size += size_for_this;
    return UACPI_ITERATION_DECISION_CONTINUE;
}

Referenced by uacpi_native_resources_to_aml().

◆ accumulate_native_buffer_size()

static uacpi_iteration_decision accumulate_native_buffer_size	(	void *	opaque,
		uacpi_u8 *	data,
		uacpi_u16	resource_size,
		const struct uacpi_resource_spec *	spec
	)

static

Definition at line 1938 of file resources.c.

{
    struct resource_conversion_ctx *ctx = opaque;
    uacpi_size size_for_this;
 
    size_for_this = native_size_for_aml_resource(data, resource_size, spec);
    if (size_for_this == 0 || (ctx->size + size_for_this) < ctx->size) {
        uacpi_error("invalid native size for aml resource: %zu\n",
                    size_for_this);
        ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
        return UACPI_ITERATION_DECISION_BREAK;
    }
 
    ctx->size += size_for_this;
    return conditional_continue(ctx);
}

Referenced by uacpi_get_resource_from_buffer(), and uacpi_native_resources_from_aml().

◆ aml_serial_to_native_type()

static uacpi_resource_type aml_serial_to_native_type ( uacpi_u8 type )

static

Definition at line 1665 of file resources.c.

{
    return (type - ACPI_SERIAL_TYPE_I2C) +
           UACPI_RESOURCE_TYPE_SERIAL_I2C_CONNECTION;
}

Referenced by do_aml_resource_to_native(), and do_native_resource_to_aml().

◆ aml_size_for_native_resource()

static uacpi_size aml_size_for_native_resource	(	uacpi_resource *	resource,
		const struct uacpi_resource_spec *	spec
	)

static

Definition at line 2180 of file resources.c.

{
    return spec->size_for_aml ?
           spec->size_for_aml(spec, resource) :
           aml_size_with_header(spec);
}

Referenced by accumulate_aml_buffer_size(), and do_native_resource_to_aml().

◆ aml_size_for_serial_connection()

static uacpi_size aml_size_for_serial_connection	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 563 of file resources.c.

{
    uacpi_size size;
    uacpi_resource_serial_bus_common *serial_bus = &resource->serial_bus_common;
 
    size = aml_size_with_header(spec);
    size += aml_serial_resource_to_extra_aml_size[serial_bus->type];
    size += serial_bus->vendor_data_length;
    size += serial_bus->source.length;
 
    return size;
}

◆ aml_size_with_header()

static uacpi_size aml_size_with_header ( const struct uacpi_resource_spec * spec )

static

Definition at line 125 of file resources.c.

{
    return spec->aml_size +
           aml_resource_kind_to_header_size[spec->resource_kind];
}

Referenced by aml_size_for_native_resource(), aml_size_for_serial_connection(), size_for_aml_address_or_clock_input(), size_for_aml_extended_irq(), size_for_aml_gpio_or_pins(), size_for_aml_irq(), size_for_aml_pin_group(), and size_for_aml_start_dependent().

◆ conditional_continue()

static uacpi_iteration_decision conditional_continue ( struct resource_conversion_ctx * ctx )

static

Definition at line 1561 of file resources.c.

{
    return ctx->just_one ? UACPI_ITERATION_DECISION_BREAK :
                           UACPI_ITERATION_DECISION_CONTINUE;
}

Referenced by accumulate_native_buffer_size(), and do_aml_resource_to_native().

◆ do_aml_resource_to_native()

static uacpi_iteration_decision do_aml_resource_to_native	(	void *	opaque,
		uacpi_u8 *	data,
		uacpi_u16	aml_size,
		const struct uacpi_resource_spec *	spec
	)

static

Definition at line 1673 of file resources.c.

{
    struct resource_conversion_ctx *ctx = opaque;
    uacpi_resource *resource = ctx->buf;
    const struct uacpi_resource_convert_instruction *insns, *insn;
    uacpi_u8 header_size, pc = 0;
    uacpi_u8 *src, *dst;
    void *resource_end;
    uacpi_u16 base_aml_size;
    uacpi_u32 base_aml_size_with_header, accumulator = 0;
 
    insns = spec->to_native;
 
    header_size = aml_resource_kind_to_header_size[spec->resource_kind];
    resource->type = spec->native_type;
    resource->length = native_size_for_aml_resource(data, aml_size, spec);
    resource_end = ctx->byte_buf + spec->native_size;
    ctx->byte_buf += resource->length;
 
    base_aml_size = base_aml_size_with_header = spec->aml_size;
    base_aml_size_with_header += header_size;
 
    if (insns == UACPI_NULL)
        return conditional_continue(ctx);
 
    for (;;) {
        insn = &insns[pc++];
 
        src = data + insn->aml_offset;
        dst = NATIVE_OFFSET(resource, insn->native_offset);
 
        switch (insn->code) {
        case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8:
        case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16: {
            uacpi_size i, j, max_bit;
            uacpi_u16 value;
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16) {
                max_bit = 16;
                uacpi_memcpy(&value, src, sizeof(uacpi_u16));
            } else {
                max_bit = 8;
                uacpi_memcpy_zerout(
                    &value, src, sizeof(value), sizeof(uacpi_u8)
                );
            }
 
            for (i = 0, j = 0; i < max_bit; ++i) {
                if (!(value & (1 << i)))
                    continue;
 
                dst[j++] = i;
            }
 
            uacpi_memcpy(NATIVE_OFFSET(resource, insn->arg2), &j, 1);
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6:{
            uacpi_u8 mask, value;
 
            mask = (insn->code - UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1) + 1;
            mask = (1 << mask) - 1;
 
            value = (*src >> insn->imm) & mask;
            uacpi_memcpy(dst, &value, sizeof(value));
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32:
            accumulator = aml_size;
            uacpi_memcpy(dst, &accumulator, 4);
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE:
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX:
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL: {
            uacpi_size offset = 0, max_offset, length = 0;
            uacpi_char *src_string, *dst_string;
            union {
                void *ptr;
                uacpi_resource_source *source;
                uacpi_resource_label *label;
            } dst_name = { .ptr = dst };
 
            /*
             * Check if the string is bounded by anything at the top. If not, we
             * just assume it ends at the end of the resource.
             */
            if (insn->arg2) {
                uacpi_memcpy_zerout(&max_offset, data + insn->arg2,
                                    sizeof(max_offset), sizeof(uacpi_u16));
                CHECK_AML_OFFSET(max_offset, "resource source");
            } else {
                max_offset = aml_size + header_size;
            }
 
            offset += base_aml_size_with_header;
            offset += accumulator;
 
            if (insn->code != UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL)
                dst_name.source->index_present = UACPI_TRUE;
 
            if (offset >= max_offset) {
                if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE)
                    dst_name.source->index_present = UACPI_FALSE;
                break;
            }
 
            src_string = PTR_AT(data, offset);
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE) {
                uacpi_memcpy(&dst_name.source->index, src_string++, 1);
                offset++;
            }
 
            if (offset == max_offset)
                break;
 
            while (offset++ < max_offset) {
                if (src_string[length++] == '\0')
                    break;
            }
 
            if (src_string[length - 1] != '\0') {
                uacpi_error("non-null-terminated resource source string\n");
                ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
                return UACPI_ITERATION_DECISION_BREAK;
            }
 
            dst_string = PTR_AT(resource_end, accumulator);
            uacpi_memcpy(dst_string, src_string, length);
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL) {
                dst_name.label->length = length;
                dst_name.label->string = dst_string;
            } else {
                dst_name.source->length = length;
                dst_name.source->string = dst_string;
            }
 
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH:
            uacpi_memcpy_zerout(&accumulator, src,
                                sizeof(accumulator), sizeof(uacpi_u16));
            CHECK_AML_OFFSET(accumulator, "pin table");
 
            accumulator -= base_aml_size_with_header;
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE: {
            uacpi_u16 entry_count = accumulator / 2;
 
            /*
             * Pin table is stored right at the end of the resource buffer,
             * copy the data there.
             */
            uacpi_memcpy(
                resource_end,
                data + base_aml_size_with_header,
                accumulator
            );
 
            // Set pin_table_length
            uacpi_memcpy(dst, &entry_count, sizeof(entry_count));
 
            // Set pin_table pointer
            uacpi_memcpy(NATIVE_OFFSET(resource, insn->arg2),
                         &resource_end, sizeof(void*));
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA: {
            uacpi_size length;
            uacpi_u16 data_offset, offset_from_end;
            void *native_dst, *vendor_data;
 
            uacpi_memcpy(&data_offset, src, sizeof(data_offset));
            CHECK_AML_OFFSET(data_offset, "vendor data");
 
            vendor_data = data + data_offset;
 
            /*
             * Rebase the offset to cut off the header as it's not included
             * in the size fields.
             */
            data_offset -= header_size;
 
            length = aml_size - data_offset;
            if (length == 0)
                break;
 
            uacpi_memcpy(dst, &length, sizeof(uacpi_u16));
 
            offset_from_end = data_offset - base_aml_size;
            native_dst = PTR_AT(resource_end, offset_from_end);
 
            uacpi_memcpy(native_dst, vendor_data, length);
            uacpi_memcpy(NATIVE_OFFSET(resource, insn->arg2),
                         &native_dst, sizeof(void*));
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC: {
            uacpi_resource_serial_bus_common *serial_bus_common;
            uacpi_u8 serial_type, extra_size, type_length;
 
            serial_bus_common = &resource->serial_bus_common;
            serial_type = *src;
            serial_bus_common->type = serial_type;
            resource->type = aml_serial_to_native_type(serial_type);
 
            /*
             * Now that we know the serial type rebase the end pointers and
             * sizes.
             */
            resource_end = PTR_AT(
                resource_end,
                aml_serial_resource_to_extra_native_size[serial_type]
            );
            extra_size = aml_serial_resource_to_extra_aml_size[serial_type];
            base_aml_size += extra_size;
            base_aml_size_with_header += extra_size;
 
            type_length = serial_bus_common->type_data_length;
            if (uacpi_unlikely(type_length < extra_size)) {
                uacpi_error(
                    "invalid type-specific data length: %d, "
                    "expected at least %d\n", type_length, extra_size
                );
                ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;
                return UACPI_ITERATION_DECISION_BREAK;
            }
 
            /*
             * Calculate the length of the vendor data. All the extra data
             * beyond the end of type-specific size is considered vendor data.
             */
            accumulator = type_length - extra_size;
            if (accumulator == 0)
                break;
 
            serial_bus_common->vendor_data_length = accumulator;
            serial_bus_common->vendor_data = resource_end;
            uacpi_memcpy(
                resource_end,
                data + base_aml_size_with_header,
                accumulator
            );
            break;
        }
 
        CONVERSION_OPCODES_COMMON(dst)
        }
    }
}

Referenced by uacpi_get_resource_from_buffer(), and uacpi_native_resources_from_aml().

◆ do_native_resource_to_aml()

static uacpi_iteration_decision do_native_resource_to_aml	(	void *	opaque,
		uacpi_resource *	resource
	)

static

Definition at line 2189 of file resources.c.

{
    struct resource_conversion_ctx *ctx = opaque;
    const struct uacpi_resource_spec *spec;
    const struct uacpi_resource_convert_instruction *insns, *insn;
    uacpi_u8 pc = 0;
    uacpi_u8 *dst_base, *src, *dst;
    uacpi_u32 aml_size, base_aml_size_with_header, accumulator = 0;
    void *resource_end;
 
    spec = resource_spec_from_native(resource);
    aml_size = aml_size_for_native_resource(resource, spec);
    insns = spec->to_aml;
 
    dst_base = ctx->byte_buf;
    ctx->byte_buf += aml_size;
    aml_size -= aml_resource_kind_to_header_size[spec->resource_kind];
 
    base_aml_size_with_header = spec->aml_size;
    base_aml_size_with_header += aml_resource_kind_to_header_size[
        spec->resource_kind
    ];
    resource_end = PTR_AT(resource, spec->native_size);
 
    if (spec->resource_kind == UACPI_AML_RESOURCE_KIND_LARGE) {
        *dst_base = ACPI_LARGE_ITEM | type_to_aml_resource[spec->type];
        uacpi_memcpy(dst_base + 1, &aml_size, sizeof(uacpi_u16));
    } else {
        *dst_base = type_to_aml_resource[spec->type] << ACPI_SMALL_ITEM_NAME_IDX;
        *dst_base |= aml_size;
    }
 
    if (insns == UACPI_NULL)
        return UACPI_ITERATION_DECISION_CONTINUE;
 
    for (;;) {
        insn = &insns[pc++];
 
        src = NATIVE_OFFSET(resource, insn->native_offset);
        dst = dst_base + insn->aml_offset;
 
        switch (insn->code) {
        case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_8:
        case UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16: {
            uacpi_u8 i, *array_size, bytes = 1;
            uacpi_u16 mask = 0;
 
            array_size = NATIVE_OFFSET(resource, insn->arg2);
            for (i = 0; i < *array_size; ++i)
                mask |= 1 << src[i];
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_PACKED_ARRAY_16)
                bytes = 2;
 
            uacpi_memcpy(dst, &mask, bytes);
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_1:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_2:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_3:
        case UACPI_RESOURCE_CONVERT_OPCODE_BIT_FIELD_6:
            *dst |= *src << insn->imm;
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_AML_SIZE_32:
            accumulator = aml_size;
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE:
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE_NO_INDEX:
        case UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL: {
            uacpi_size source_offset, length;
            uacpi_u8 *dst_string;
            const uacpi_char *src_string;
            union {
                void *ptr;
                uacpi_resource_source *source;
                uacpi_resource_label *label;
            } src_name = { .ptr = src };
 
            source_offset = base_aml_size_with_header + accumulator;
            dst_string = dst_base + source_offset;
 
            if (insn->aml_offset)
                uacpi_memcpy(dst, &source_offset, sizeof(uacpi_u16));
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_SOURCE &&
                src_name.source->index_present)
                uacpi_memcpy(dst_string++, &src_name.source->index, 1);
 
            if (insn->code == UACPI_RESOURCE_CONVERT_OPCODE_RESOURCE_LABEL) {
                length = src_name.label->length;
                src_string = src_name.label->string;
            } else {
                length = src_name.source->length;
                src_string = src_name.source->string;
            }
 
            if (length == 0)
                break;
 
            if (uacpi_unlikely(src_string == UACPI_NULL)) {
                uacpi_error(
                    "source string length is %zu but the pointer is NULL\n",
                    length
                );
                ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
                return UACPI_ITERATION_DECISION_BREAK;
            }
 
            uacpi_memcpy(dst_string, src_string, length);
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_LOAD_PIN_TABLE_LENGTH:
            uacpi_memcpy_zerout(&accumulator, src,
                                sizeof(accumulator), sizeof(uacpi_u16));
            accumulator *= sizeof(uacpi_u16);
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_PIN_TABLE:
            /*
             * The pin table resides right at the end of the base resource,
             * set the offset to it in the AML we're encoding.
             */
            uacpi_memcpy(dst, &base_aml_size_with_header, sizeof(uacpi_u16));
 
            /*
             * Copy the actual data. It also resides right at the end of the
             * native base resource.
             */
            uacpi_memcpy(
                dst_base + base_aml_size_with_header,
                resource_end,
                accumulator
            );
            break;
 
        case UACPI_RESOURCE_CONVERT_OPCODE_VENDOR_DATA: {
            uacpi_u16 vendor_data_length, data_offset, vendor_data_offset;
            uacpi_u8 *vendor_data;
 
            // Read the vendor_data pointer
            uacpi_memcpy(&vendor_data, NATIVE_OFFSET(resource, insn->arg2),
                         sizeof(void*));
            uacpi_memcpy(&vendor_data_length, src, sizeof(uacpi_u16));
 
            if (vendor_data == UACPI_NULL) {
                uacpi_size full_aml_size;
 
                if (uacpi_unlikely(vendor_data_length != 0)) {
                    uacpi_error(
                        "vendor_data_length is %d, but pointer is NULL\n",
                        vendor_data_length
                    );
                    ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
                    return UACPI_ITERATION_DECISION_BREAK;
                }
 
                /*
                 * There's no vendor data. The specification still mandates
                 * that we fill the vendor data offset field correctly, meaning
                 * we set it to the total length of the resource.
                 */
                full_aml_size = aml_size;
                full_aml_size += aml_resource_kind_to_header_size[
                    spec->resource_kind
                ];
 
                uacpi_memcpy(dst, &full_aml_size, sizeof(uacpi_u16));
                break;
            }
 
            /*
             * Calculate the offset of vendor data from the end of the native
             * resource and use it since it matches the offset from the end of
             * the AML resource.
             *
             * Non-zero value means there's a source string in between.
             */
            data_offset = vendor_data - (uacpi_u8*)resource_end;
            vendor_data_offset = data_offset + base_aml_size_with_header;
 
            // Write vendor_data_offset
            uacpi_memcpy(dst, &vendor_data_offset, sizeof(uacpi_u16));
 
            /*
             * Write vendor_data_length, this field is right after
             * vendor_data_offset, and is completely redundant, but it exists
             * nonetheless.
             */
            uacpi_memcpy(
                dst + sizeof(uacpi_u16),
                &vendor_data_length,
                sizeof(vendor_data_length)
            );
 
            // Finally write the data itself
            uacpi_memcpy(
                dst_base + vendor_data_offset,
                vendor_data,
                vendor_data_length
            );
            break;
        }
 
        case UACPI_RESOURCE_CONVERT_OPCODE_SERIAL_TYPE_SPECIFIC: {
            uacpi_u8 serial_type = *src;
            *dst = serial_type;
 
            ctx->st = validate_aml_serial_type(serial_type);
            if (uacpi_unlikely_error(ctx->st))
                return UACPI_ITERATION_DECISION_BREAK;
 
            if (uacpi_unlikely(resource->type !=
                               aml_serial_to_native_type(serial_type))) {
                uacpi_error(
                    "native serial resource type %d doesn't match expected %d\n",
                    resource->type, aml_serial_to_native_type(serial_type)
                );
                ctx->st = UACPI_STATUS_INVALID_ARGUMENT;
                return UACPI_ITERATION_DECISION_BREAK;
            }
 
            // Rebase the end pointer & size now that we know the serial type
            resource_end = PTR_AT(
                resource_end,
                aml_serial_resource_to_extra_native_size[serial_type]
            );
            base_aml_size_with_header += aml_serial_resource_to_extra_aml_size[
                serial_type
            ];
 
            accumulator = resource->serial_bus_common.vendor_data_length;
            if (accumulator == 0)
                break;
 
            // Copy vendor data
            uacpi_memcpy(
                dst_base + base_aml_size_with_header,
                resource_end,
                accumulator
            );
            break;
        }
 
        CONVERSION_OPCODES_COMMON(src)
        }
    }
}

Referenced by native_resources_to_aml().

◆ eval_resource_helper()

static uacpi_status eval_resource_helper	(	uacpi_namespace_node *	node,
		const uacpi_char *	method,
		uacpi_object **	out_obj
	)

static

Definition at line 1958 of file resources.c.

{
    uacpi_status ret;
    uacpi_bool is_device;
 
    ret = uacpi_namespace_node_is(node, UACPI_OBJECT_DEVICE, &is_device);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (uacpi_unlikely(!is_device))
        return UACPI_STATUS_INVALID_ARGUMENT;
 
    return uacpi_eval_simple_buffer(
        node, method, out_obj
    );
}

Referenced by extract_native_resources_from_method().

◆ extra_size_for_extended_irq()

static uacpi_size extra_size_for_extended_irq	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 327 of file resources.c.

{
    struct acpi_resource_extended_irq *irq = data;
    uacpi_size extra_size = 0;
 
    extra_size += irq->num_irqs * sizeof(uacpi_u32);
    extra_size += extra_size_for_resource_source(
        spec->aml_size, size - extra_size
    );
 
    return extra_size;
}

◆ extra_size_for_native_address_or_clock_input()

static uacpi_size extra_size_for_native_address_or_clock_input	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 290 of file resources.c.

{
    UACPI_UNUSED(data);
    return extra_size_for_resource_source(spec->aml_size, size);
}

◆ extra_size_for_native_gpio_or_pins()

static uacpi_size extra_size_for_native_gpio_or_pins	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 356 of file resources.c.

{
    uacpi_size pin_table_offset;
 
    /*
     * These resources pretend to have variable layout by declaring "offset"
     * fields, but the layout is hardcoded and mandated by the spec to be
     * very specific. We can use the offset numbers here to calculate the final
     * length.
     *
     * For example, the layout of GPIO connection _always_ looks as follows:
     * [0...22] -> fixed data
     * [23...<source name offset - 1>] -> pin table
     * [<source name offset>...<vendor data offset - 1>] -> source name
     * [<vendor data offset>...<data offset + data length>] -> vendor data
     */
    switch (spec->type) {
    case UACPI_AML_RESOURCE_GPIO_CONNECTION: {
        struct acpi_resource_gpio_connection *gpio = data;
        pin_table_offset = gpio->pin_table_offset;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_FUNCTION: {
        struct acpi_resource_pin_function *pin = data;
        pin_table_offset = pin->pin_table_offset;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_CONFIGURATION: {
        struct acpi_resource_pin_configuration *config = data;
        pin_table_offset = config->pin_table_offset;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_GROUP: {
        struct acpi_resource_pin_group *group = data;
        pin_table_offset = group->pin_table_offset;
        break;
    }
 
    default:
        return 0;
    }
 
    /*
     * The size we get passed here does not include the header size because
     * that's how resources are encoded. Subtract it here so that we get the
     * correct final length.
     */
    return size - (pin_table_offset - LARGE_ITEM_HEADER_SIZE);
}

◆ extra_size_for_native_irq_or_dma()

static uacpi_size extra_size_for_native_irq_or_dma	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 131 of file resources.c.

{
    UACPI_UNUSED(size);
    uacpi_u16 mask;
    uacpi_u8 i, total_bits, num_bits = 0;
 
    if (spec->type == UACPI_AML_RESOURCE_IRQ) {
        struct acpi_resource_irq *irq = data;
        mask = irq->irq_mask;
        total_bits = 16;
    } else {
        struct acpi_resource_dma *dma = data;
        mask = dma->channel_mask;
        total_bits = 8;
    }
 
    for (i = 0; i < total_bits; ++i)
        num_bits += !!(mask & (1 << i));
 
    return num_bits;
}

◆ extra_size_for_native_pin_group()

static uacpi_size extra_size_for_native_pin_group	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 462 of file resources.c.

{
    uacpi_size source_offset;
 
    switch (spec->type) {
    case UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION: {
        struct acpi_resource_pin_group_function *func = data;
        source_offset = func->source_offset;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION: {
        struct acpi_resource_pin_group_configuration *config = data;
        source_offset = config->source_offset;
        break;
    }
 
    default:
        return 0;
    }
 
    // Same logic as extra_size_for_native_gpio_or_pins
    return size - (source_offset - LARGE_ITEM_HEADER_SIZE);
}

◆ extra_size_for_native_vendor()

static uacpi_size extra_size_for_native_vendor	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 220 of file resources.c.

{
    UACPI_UNUSED(spec);
    UACPI_UNUSED(data);
    return size;
}

◆ extra_size_for_resource_source()

static uacpi_size extra_size_for_resource_source	(	uacpi_size	base_size,
		uacpi_size	reported_size
	)

static

Definition at line 255 of file resources.c.

{
    uacpi_size string_length;
 
    if (reported_size <= base_size)
        return 0;
 
    /*
     * The remainder of the descriptor minus the resource index field
     */
    string_length = (reported_size - base_size) - 1;
    return UACPI_ALIGN_UP(string_length, sizeof(void*), uacpi_size);
}

Referenced by extra_size_for_extended_irq(), and extra_size_for_native_address_or_clock_input().

◆ extra_size_for_serial_connection()

static uacpi_size extra_size_for_serial_connection	(	const struct uacpi_resource_spec *	spec,
		void *	data,
		uacpi_size	size
	)

static

Definition at line 549 of file resources.c.

{
    struct acpi_resource_serial *serial = data;
    uacpi_size extra_bytes = size;
 
    extra_bytes -= spec->aml_size;
    extra_bytes -= aml_serial_resource_to_extra_aml_size[serial->type];
    extra_bytes += aml_serial_resource_to_extra_native_size[serial->type];
 
    return extra_bytes;
}

◆ extract_native_resources_from_method()

static uacpi_status extract_native_resources_from_method	(	uacpi_namespace_node *	device,
		const uacpi_char *	method,
		uacpi_resources **	out_resources
	)

static

Definition at line 2072 of file resources.c.

{
    uacpi_status ret;
    uacpi_object *obj;
    uacpi_data_view buffer;
 
    ret = eval_resource_helper(device, method, &obj);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    uacpi_buffer_to_view(obj->buffer, &buffer);
 
    ret = uacpi_native_resources_from_aml(buffer, out_resources);
    uacpi_object_unref(obj);
 
    return ret;
}

Referenced by uacpi_for_each_device_resource(), uacpi_get_current_resources(), uacpi_get_device_resources(), and uacpi_get_possible_resources().

◆ find_end()

static uacpi_iteration_decision find_end	(	void *	opaque,
		uacpi_u8 *	data,
		uacpi_u16	resource_size,
		const struct uacpi_resource_spec *	spec
	)

static

Definition at line 1499 of file resources.c.

{
    uacpi_u8 **out_ptr = opaque;
    UACPI_UNUSED(resource_size);
 
    if (spec->type != UACPI_AML_RESOURCE_END_TAG)
        return UACPI_ITERATION_DECISION_CONTINUE;
 
    *out_ptr = data;
    return UACPI_ITERATION_DECISION_BREAK;
}

Referenced by uacpi_find_aml_resource_end_tag().

◆ get_aml_resource_size()

static uacpi_status get_aml_resource_size	(	uacpi_u8 *	data,
		uacpi_size	bytes_left,
		uacpi_u16 *	out_size
	)

static

Definition at line 1380 of file resources.c.

{
    uacpi_u16 size;
 
    /*
     * Resource header is not included in size for both, so we subtract
     * the header size from bytes_left to validate it.
     */
    if (*data & ACPI_LARGE_ITEM) {
        if (uacpi_unlikely(bytes_left < 3))
            return UACPI_STATUS_AML_INVALID_RESOURCE;
 
        uacpi_memcpy(&size, data + 1, sizeof(size));
        bytes_left -= aml_resource_kind_to_header_size[
            UACPI_AML_RESOURCE_KIND_LARGE
        ];
    } else {
        size = *data & ACPI_SMALL_ITEM_LENGTH_MASK;
        bytes_left -= aml_resource_kind_to_header_size[
            UACPI_AML_RESOURCE_KIND_SMALL
        ];
    }
 
    if (uacpi_unlikely(size > bytes_left))
        return UACPI_STATUS_AML_INVALID_RESOURCE;
 
    *out_size = size;
    return UACPI_STATUS_OK;
}

Referenced by uacpi_for_each_aml_resource().

◆ get_aml_resource_type()

static enum uacpi_aml_resource get_aml_resource_type ( uacpi_u8 raw_byte )

static

Definition at line 1367 of file resources.c.

{
    if (raw_byte & ACPI_LARGE_ITEM) {
        return aml_resource_to_type[
            LARGE_RESOURCE_BASE + (raw_byte & ACPI_LARGE_ITEM_NAME_MASK)
        ];
    }
 
    return aml_resource_to_type[
        (raw_byte >> ACPI_SMALL_ITEM_NAME_IDX) & ACPI_SMALL_ITEM_NAME_MASK
    ];
}

Referenced by uacpi_for_each_aml_resource().

◆ native_resources_to_aml()

static uacpi_status native_resources_to_aml	(	uacpi_resources *	native_resources,
		void *	aml_buffer
	)

static

Definition at line 2445 of file resources.c.

{
    uacpi_status ret;
    struct resource_conversion_ctx ctx = {
        .buf = aml_buffer,
    };
 
    ret = uacpi_for_each_resource(
        native_resources, do_native_resource_to_aml, &ctx
    );
    if (ret == UACPI_STATUS_NO_RESOURCE_END_TAG) {
        // An end tag is always included
        do_native_resource_to_aml(&ctx, INLINE_END_TAG);
        ret = UACPI_STATUS_OK;
    }
    if (uacpi_unlikely_error(ret))
        return ret;
 
    return ctx.st;
}

Referenced by uacpi_native_resources_to_aml().

◆ native_size_for_aml_resource()

static uacpi_size native_size_for_aml_resource	(	uacpi_u8 *	data,
		uacpi_u16	size,
		const struct uacpi_resource_spec *	spec
	)

static

Definition at line 1514 of file resources.c.

{
    uacpi_size final_size = spec->native_size;
 
    if (spec->extra_size_for_native)
        final_size += spec->extra_size_for_native(spec, data, size);
 
    return UACPI_ALIGN_UP(final_size, sizeof(void*), uacpi_size);
}

Referenced by accumulate_native_buffer_size(), and do_aml_resource_to_native().

◆ resource_spec_from_native()

static const struct uacpi_resource_spec * resource_spec_from_native ( uacpi_resource * resource )

static

Definition at line 2173 of file resources.c.

{
    return &aml_resources[native_resource_to_type[resource->type]];
}

Referenced by accumulate_aml_buffer_size(), and do_native_resource_to_aml().

◆ size_for_aml_address_or_clock_input()

static uacpi_size size_for_aml_address_or_clock_input	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 298 of file resources.c.

{
    uacpi_resource_source *source;
    bool has_index = UACPI_TRUE;
 
    switch (resource->type) {
    case UACPI_RESOURCE_TYPE_ADDRESS16:
        source = &resource->address16.source;
        break;
    case UACPI_RESOURCE_TYPE_ADDRESS32:
        source = &resource->address32.source;
        break;
    case UACPI_RESOURCE_TYPE_ADDRESS64:
        source = &resource->address64.source;
        break;
    case UACPI_RESOURCE_TYPE_CLOCK_INPUT:
        source = &resource->clock_input.source;
        has_index = UACPI_FALSE;
        break;
    default:
        return 0;
    }
 
    return aml_size_with_header(spec) +
           size_for_aml_resource_source(source, has_index);
}

◆ size_for_aml_extended_irq()

static uacpi_size size_for_aml_extended_irq	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 342 of file resources.c.

{
    uacpi_resource_extended_irq *irq = &resource->extended_irq;
    uacpi_size size;
 
    size = aml_size_with_header(spec);
    size += irq->num_irqs * 4;
    size += size_for_aml_resource_source(&irq->source, UACPI_TRUE);
 
    return size;
}

◆ size_for_aml_gpio_or_pins()

static uacpi_size size_for_aml_gpio_or_pins	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 411 of file resources.c.

{
    uacpi_size source_length, vendor_length, pin_table_length, size;
 
    size = aml_size_with_header(spec);
    switch (spec->type) {
    case UACPI_AML_RESOURCE_GPIO_CONNECTION: {
        uacpi_resource_gpio_connection *res = &resource->gpio_connection;
        source_length = res->source.length;
        pin_table_length = res->pin_table_length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_FUNCTION: {
        uacpi_resource_pin_function *res = &resource->pin_function;
        source_length = res->source.length;
        pin_table_length = res->pin_table_length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_CONFIGURATION: {
        uacpi_resource_pin_configuration *res = &resource->pin_configuration;
        source_length = res->source.length;
        pin_table_length = res->pin_table_length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_GROUP: {
        uacpi_resource_pin_group *res = &resource->pin_group;
        source_length = res->label.length;
        pin_table_length = res->pin_table_length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    default:
        return 0;
    }
 
    size += source_length;
    size += pin_table_length * 2;
    size += vendor_length;
 
    return size;
}

◆ size_for_aml_irq()

static uacpi_size size_for_aml_irq	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 155 of file resources.c.

{
    uacpi_resource_irq *irq = &resource->irq;
    uacpi_size size;
 
    size = aml_size_with_header(spec);
 
    switch (irq->length_kind) {
    case UACPI_RESOURCE_LENGTH_KIND_FULL:
        goto out_full;
    case UACPI_RESOURCE_LENGTH_KIND_ONE_LESS:
    case UACPI_RESOURCE_LENGTH_KIND_DONT_CARE:
        if (irq->triggering != UACPI_TRIGGERING_EDGE)
            goto out_full;
        if (irq->polarity != UACPI_POLARITY_ACTIVE_HIGH)
            goto out_full;
        if (irq->sharing != UACPI_EXCLUSIVE)
            goto out_full;
 
        return size - 1;
    }
 
out_full:
    if (uacpi_unlikely(irq->length_kind ==
                       UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)) {
        uacpi_warn("requested IRQ resource length is "
                   "not compatible with specified flags, corrected\n");
    }
 
    return size;
}

◆ size_for_aml_pin_group()

static uacpi_size size_for_aml_pin_group	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 489 of file resources.c.

{
    uacpi_size source_length, label_length, vendor_length, size;
 
    size = aml_size_with_header(spec);
    switch (spec->type) {
    case UACPI_AML_RESOURCE_PIN_GROUP_FUNCTION: {
        uacpi_resource_pin_group_function *res = &resource->pin_group_function;
        source_length = res->source.length;
        label_length = res->label.length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    case UACPI_AML_RESOURCE_PIN_GROUP_CONFIGURATION: {
        uacpi_resource_pin_group_configuration *res;
        res = &resource->pin_group_configuration;
        source_length = res->source.length;
        label_length = res->label.length;
        vendor_length = res->vendor_data_length;
        break;
    }
 
    default:
        return 0;
    }
 
    size += source_length;
    size += label_length;
    size += vendor_length;
 
    return size;
}

◆ size_for_aml_resource_source()

static uacpi_size size_for_aml_resource_source	(	uacpi_resource_source *	source,
		uacpi_bool	with_index
	)

static

Definition at line 271 of file resources.c.

{
    uacpi_size length = source->length;
 
    if (uacpi_unlikely(length && !source->index_present)) {
        uacpi_warn("resource declares no source index with non-empty "
                   "string (%zu bytes), corrected\n", length);
        source->index_present = UACPI_TRUE;
    }
 
    // If index is included in the dynamic resource source, add it to the length
    if (with_index)
        length += source->index_present;
 
    return length;
}

Referenced by size_for_aml_address_or_clock_input(), and size_for_aml_extended_irq().

◆ size_for_aml_start_dependent()

static uacpi_size size_for_aml_start_dependent	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 189 of file resources.c.

{
    uacpi_resource_start_dependent *start_dep = &resource->start_dependent;
    uacpi_size size;
 
    size = aml_size_with_header(spec);
    switch (start_dep->length_kind) {
    case UACPI_RESOURCE_LENGTH_KIND_FULL:
        goto out_full;
    case UACPI_RESOURCE_LENGTH_KIND_ONE_LESS:
    case UACPI_RESOURCE_LENGTH_KIND_DONT_CARE:
        if (start_dep->compatibility != UACPI_ACCEPTABLE)
            goto out_full;
        if (start_dep->performance != UACPI_ACCEPTABLE)
            goto out_full;
 
        return size - 1;
    }
 
out_full:
    if (uacpi_unlikely(start_dep->length_kind ==
                       UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)) {
        uacpi_warn("requested StartDependentFn resource length is "
                   "not compatible with specified flags, corrected\n");
    }
 
    return size;
}

◆ size_for_aml_vendor()

static uacpi_size size_for_aml_vendor	(	const struct uacpi_resource_spec *	spec,
		uacpi_resource *	resource
	)

static

Definition at line 229 of file resources.c.

{
    UACPI_UNUSED(spec);
    uacpi_size size = resource->vendor.length;
 
    if (size > 7 || resource->type == UACPI_RESOURCE_TYPE_VENDOR_LARGE) {
        size += aml_resource_kind_to_header_size[
            UACPI_AML_RESOURCE_KIND_LARGE
        ];
 
        if (uacpi_unlikely(resource->type != UACPI_RESOURCE_TYPE_VENDOR_LARGE)) {
            uacpi_warn("vendor data too large for small descriptor (%zu), "
                       "correcting to large\n", size);
            resource->type = UACPI_RESOURCE_TYPE_VENDOR_LARGE;
        }
    } else {
        size += aml_resource_kind_to_header_size[
            UACPI_AML_RESOURCE_KIND_SMALL
        ];
    }
 
    return size;
}

◆ uacpi_find_aml_resource_end_tag()

uacpi_status uacpi_find_aml_resource_end_tag	(	uacpi_data_view	buffer,
		uacpi_size *	out_offset
	)

Definition at line 1526 of file resources.c.

{
    uacpi_u8 *end_tag_ptr = UACPI_NULL;
    uacpi_status ret;
 
    if (buffer.length == 0) {
        *out_offset = 0;
        return UACPI_STATUS_OK;
    }
 
    /*
     * This returning UACPI_STATUS_OK guarantees that end_tag_ptr is set to
     * a valid value because a missing end tag would produce a
     * UACPI_STATUS_NO_RESOURCE_END_TAG error.
     */
    ret = uacpi_for_each_aml_resource(buffer, find_end, &end_tag_ptr);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    *out_offset = end_tag_ptr - buffer.bytes;
    return UACPI_STATUS_OK;
}

Referenced by handle_concatenate_res().

◆ uacpi_for_each_aml_resource()

uacpi_status uacpi_for_each_aml_resource	(	uacpi_data_view	buffer,
		uacpi_aml_resource_iteration_callback	cb,
		void *	user
	)

Definition at line 1423 of file resources.c.

{
    uacpi_status ret;
    uacpi_iteration_decision decision;
    uacpi_u8 *data;
    uacpi_size bytes_left;
    uacpi_u16 resource_size;
    enum uacpi_aml_resource type;
    const struct uacpi_resource_spec *spec;
 
    bytes_left = buffer.length;
    data = buffer.bytes;
 
    while (bytes_left) {
        type = get_aml_resource_type(*data);
        if (uacpi_unlikely(type == UACPI_AML_RESOURCE_TYPE_INVALID))
            return UACPI_STATUS_AML_INVALID_RESOURCE;
 
        ret = get_aml_resource_size(data, bytes_left, &resource_size);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        spec = &aml_resources[type];
        switch (spec->size_kind) {
        case UACPI_AML_RESOURCE_SIZE_KIND_FIXED:
            if (resource_size != spec->aml_size)
                return UACPI_STATUS_AML_INVALID_RESOURCE;
            break;
        case UACPI_AML_RESOURCE_SIZE_KIND_VARIABLE:
            if (resource_size < spec->aml_size)
                return UACPI_STATUS_AML_INVALID_RESOURCE;
            break;
        case UACPI_AML_RESOURCE_SIZE_KIND_FIXED_OR_ONE_LESS:
            if (resource_size != spec->aml_size &&
                resource_size != (spec->aml_size - 1))
                return UACPI_STATUS_AML_INVALID_RESOURCE;
            break;
        default:
            return UACPI_STATUS_INTERNAL_ERROR;
        }
 
        if (spec->type == UACPI_AML_RESOURCE_SERIAL_CONNECTION) {
            struct acpi_resource_serial *serial;
 
            serial = (struct acpi_resource_serial*)data;
 
            ret = validate_aml_serial_type(serial->type);
            if (uacpi_unlikely_error(ret))
                return ret;
        }
 
        decision = cb(user, data, resource_size, spec);
        switch (decision) {
        case UACPI_ITERATION_DECISION_BREAK:
            return UACPI_STATUS_OK;
        case UACPI_ITERATION_DECISION_CONTINUE: {
            uacpi_size total_size = resource_size;
 
            total_size += aml_resource_kind_to_header_size[spec->resource_kind];
            data += total_size;
            bytes_left -= total_size;
            break;
        }
        default:
            return UACPI_STATUS_INTERNAL_ERROR;
        }
 
        if (type == UACPI_AML_RESOURCE_END_TAG)
            return UACPI_STATUS_OK;
    }
 
    return UACPI_STATUS_NO_RESOURCE_END_TAG;
}

Referenced by uacpi_find_aml_resource_end_tag(), uacpi_get_resource_from_buffer(), and uacpi_native_resources_from_aml().

◆ uacpi_for_each_device_resource()

uacpi_status uacpi_for_each_device_resource	(	uacpi_namespace_node *	device,
		const uacpi_char *	method,
		uacpi_resource_iteration_callback	cb,
		void *	user
	)

Definition at line 2155 of file resources.c.

{
    uacpi_status ret;
    uacpi_resources *resources;
 
    ret = extract_native_resources_from_method(device, method, &resources);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    ret = uacpi_for_each_resource(resources, cb, user);
    uacpi_free_resources(resources);
 
    return ret;
}

◆ uacpi_for_each_resource()

uacpi_status uacpi_for_each_resource	(	uacpi_resources *	resources,
		uacpi_resource_iteration_callback	cb,
		void *	user
	)

Definition at line 2115 of file resources.c.

{
    uacpi_size bytes_left = resources->length;
    uacpi_resource *current = resources->entries;
    uacpi_iteration_decision decision;
 
    while (bytes_left) {
        // At least the head bytes
        if (uacpi_unlikely(bytes_left < 4)) {
            uacpi_error("corrupted resource buffer %p length %zu\n",
                        resources, resources->length);
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        if (uacpi_unlikely(current->type > UACPI_RESOURCE_TYPE_MAX)) {
            uacpi_error("invalid resource type %d\n", current->type);
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        if (uacpi_unlikely(current->length > bytes_left)) {
            uacpi_error("corrupted resource@%p length %u (%zu bytes left)\n",
                        current, current->length, bytes_left);
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        decision = cb(user, current);
 
        if (decision == UACPI_ITERATION_DECISION_BREAK ||
            current->type == UACPI_RESOURCE_TYPE_END_TAG)
            return UACPI_STATUS_OK;
 
        bytes_left -= current->length;
        current = (uacpi_resource*)((uacpi_u8*)current + current->length);
    }
 
    return UACPI_STATUS_NO_RESOURCE_END_TAG;
}

Referenced by native_resources_to_aml(), uacpi_for_each_device_resource(), and uacpi_native_resources_to_aml().

◆ uacpi_free_resource()

void uacpi_free_resource ( uacpi_resource * resource )

Definition at line 2064 of file resources.c.

{
    if (resource == UACPI_NULL)
        return;
 
    uacpi_free(resource, resource->length);
}

Referenced by uacpi_get_resource_from_buffer().

◆ uacpi_free_resources()

void uacpi_free_resources ( uacpi_resources * resources )

Definition at line 2056 of file resources.c.

{
    if (resources == UACPI_NULL)
        return;
 
    uacpi_free(resources, sizeof(uacpi_resources) + resources->length);
}

Referenced by uacpi_for_each_device_resource(), and uacpi_native_resources_from_aml().

◆ uacpi_get_current_resources()

uacpi_status uacpi_get_current_resources	(	uacpi_namespace_node *	device,
		uacpi_resources **	out_resources
	)

Definition at line 2093 of file resources.c.

{
    return extract_native_resources_from_method(device, "_CRS", out_resources);
}

◆ uacpi_get_device_resources()

uacpi_status uacpi_get_device_resources	(	uacpi_namespace_node *	device,
		const uacpi_char *	method,
		uacpi_resources **	out_resources
	)

Definition at line 2107 of file resources.c.

{
    return extract_native_resources_from_method(device, method, out_resources);
}

◆ uacpi_get_possible_resources()

uacpi_status uacpi_get_possible_resources	(	uacpi_namespace_node *	device,
		uacpi_resources **	out_resources
	)

Definition at line 2100 of file resources.c.

{
    return extract_native_resources_from_method(device, "_PRS", out_resources);
}

◆ uacpi_get_resource_from_buffer()

uacpi_status uacpi_get_resource_from_buffer	(	uacpi_data_view	aml_buffer,
		uacpi_resource **	out_resource
	)

Definition at line 2021 of file resources.c.

{
    uacpi_status ret;
    struct resource_conversion_ctx ctx = {
        .just_one = UACPI_TRUE,
    };
    uacpi_resource *resource;
 
    ret = uacpi_for_each_aml_resource(
        aml_buffer, accumulate_native_buffer_size, &ctx
    );
    if (uacpi_unlikely_error(ret))
        return ret;
 
    resource = uacpi_kernel_alloc_zeroed(ctx.size);
    if (uacpi_unlikely(resource == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    ctx = (struct resource_conversion_ctx) {
        .buf = resource,
        .just_one = UACPI_TRUE,
    };
 
    ret = uacpi_for_each_aml_resource(aml_buffer, do_aml_resource_to_native, &ctx);
    if (uacpi_unlikely_error(ret)) {
        uacpi_free_resource(resource);
        return ret;
    }
 
    *out_resource = resource;
    return ret;
}

◆ uacpi_native_resources_from_aml()

uacpi_status uacpi_native_resources_from_aml	(	uacpi_data_view	aml_buffer,
		uacpi_resources **	out_resources
	)

Definition at line 1978 of file resources.c.

{
    uacpi_status ret;
    struct resource_conversion_ctx ctx = { 0 };
    uacpi_resources *resources;
 
    ret = uacpi_for_each_aml_resource(
        aml_buffer, accumulate_native_buffer_size, &ctx
    );
    if (uacpi_unlikely_error(ret))
        return ret;
 
    if (uacpi_unlikely_error(ctx.st))
        return ctx.st;
 
    // Realistically any resource buffer bigger than this is probably a bug
    if (uacpi_unlikely(ctx.size > (5 * 1024u * 1024u))) {
        uacpi_error("bug: bogus native resource buffer size %zu\n", ctx.size);
        return UACPI_STATUS_INTERNAL_ERROR;
    }
 
    resources = uacpi_kernel_alloc_zeroed(ctx.size + sizeof(uacpi_resources));
    if (uacpi_unlikely(resources == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
    resources->length = ctx.size;
    resources->entries = UACPI_PTR_ADD(resources, sizeof(uacpi_resources));
 
    ctx = (struct resource_conversion_ctx) {
        .buf = resources->entries,
    };
 
    ret = uacpi_for_each_aml_resource(aml_buffer, do_aml_resource_to_native, &ctx);
    if (uacpi_unlikely_error(ret)) {
        uacpi_free_resources(resources);
        return ret;
    }
 
    *out_resources = resources;
    return ret;
}

Referenced by extract_native_resources_from_method().

◆ uacpi_native_resources_to_aml()

uacpi_status uacpi_native_resources_to_aml	(	uacpi_resources *	resources,
		uacpi_object **	out_template
	)

Definition at line 2491 of file resources.c.

{
    uacpi_status ret;
    uacpi_object *obj;
    void *buffer;
    struct resource_conversion_ctx ctx = { 0 };
 
    ret = uacpi_for_each_resource(
        resources, accumulate_aml_buffer_size, &ctx
    );
    if (ret == UACPI_STATUS_NO_RESOURCE_END_TAG) {
        // An end tag is always included
        accumulate_aml_buffer_size(&ctx, INLINE_END_TAG);
        ret = UACPI_STATUS_OK;
    }
    if (uacpi_unlikely_error(ret))
        return ret;
    if (uacpi_unlikely_error(ctx.st))
        return ctx.st;
 
    // Same reasoning as native_resource_from_aml
    if (uacpi_unlikely(ctx.size > (5 * 1024u * 1024u))) {
        uacpi_error("bug: bogus target aml resource buffer size %zu\n",
                    ctx.size);
        return UACPI_STATUS_INTERNAL_ERROR;
    }
 
    buffer = uacpi_kernel_alloc_zeroed(ctx.size);
    if (uacpi_unlikely(buffer == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    obj = uacpi_create_object(UACPI_OBJECT_BUFFER);
    if (uacpi_unlikely(obj == UACPI_NULL)) {
        uacpi_free(buffer, ctx.size);
        return UACPI_STATUS_OUT_OF_MEMORY;
    }
 
    obj->buffer->data = buffer;
    obj->buffer->size = ctx.size;
 
    ret = native_resources_to_aml(resources, buffer);
    if (uacpi_unlikely_error(ret))
        uacpi_object_unref(obj);
 
    if (ret == UACPI_STATUS_OK)
        *out_template = obj;
 
    return ret;
}

Referenced by uacpi_set_resources().

◆ uacpi_set_resources()

uacpi_status uacpi_set_resources	(	uacpi_namespace_node *	device,
		uacpi_resources *	resources
	)

Definition at line 2543 of file resources.c.

{
    uacpi_status ret;
    uacpi_object *res_template;
    uacpi_object_array args;
 
    ret = uacpi_native_resources_to_aml(resources, &res_template);
    if (uacpi_unlikely_error(ret))
        return ret;
 
    args.objects = &res_template;
    args.count = 1;
    ret = uacpi_eval(device, "_SRS", &args, UACPI_NULL);
 
    uacpi_object_unref(res_template);
    return ret;
}

◆ validate_aml_serial_type()

static uacpi_status validate_aml_serial_type ( uacpi_u8 type )

static

Definition at line 1412 of file resources.c.

{
    if (uacpi_unlikely(type < ACPI_SERIAL_TYPE_I2C ||
                       type > ACPI_SERIAL_TYPE_CSI2)) {
        uacpi_error("invalid/unsupported serial connection type %d\n", type);
        return UACPI_STATUS_AML_INVALID_RESOURCE;
    }
 
    return UACPI_STATUS_OK;
}

Referenced by do_native_resource_to_aml(), and uacpi_for_each_aml_resource().

Variable Documentation

◆ aml_resource_kind_to_header_size

const uacpi_u8 aml_resource_kind_to_header_size[2]

static

Initial value:

= {
    [UACPI_AML_RESOURCE_KIND_SMALL] = SMALL_ITEM_HEADER_SIZE,
    [UACPI_AML_RESOURCE_KIND_LARGE] = LARGE_ITEM_HEADER_SIZE,
}

Definition at line 120 of file resources.c.

Referenced by aml_size_with_header(), do_aml_resource_to_native(), do_native_resource_to_aml(), get_aml_resource_size(), size_for_aml_vendor(), and uacpi_for_each_aml_resource().

◆ aml_resource_to_type

const uacpi_u8 aml_resource_to_type[256]

static

Definition at line 19 of file resources.c.

Referenced by get_aml_resource_type().

◆ aml_resources

const struct uacpi_resource_spec aml_resources[UACPI_AML_RESOURCE_MAX+1]

Definition at line 1095 of file resources.c.

Referenced by resource_spec_from_native(), and uacpi_for_each_aml_resource().

◆ aml_serial_resource_to_extra_aml_size

const uacpi_u8 aml_serial_resource_to_extra_aml_size[ACPI_SERIAL_TYPE_MAX+1]

static

Initial value:

= {
    [ACPI_SERIAL_TYPE_I2C] = AML_SERIAL_RESOURCE_EXTRA_SIZE(i2c),
    [ACPI_SERIAL_TYPE_SPI] = AML_SERIAL_RESOURCE_EXTRA_SIZE(spi),
    [ACPI_SERIAL_TYPE_UART] = AML_SERIAL_RESOURCE_EXTRA_SIZE(uart),
    [ACPI_SERIAL_TYPE_CSI2] = AML_SERIAL_RESOURCE_EXTRA_SIZE(csi2),
}

Definition at line 533 of file resources.c.

Referenced by aml_size_for_serial_connection(), do_aml_resource_to_native(), do_native_resource_to_aml(), and extra_size_for_serial_connection().

◆ aml_serial_resource_to_extra_native_size

const uacpi_u8 aml_serial_resource_to_extra_native_size[ACPI_SERIAL_TYPE_MAX+1]

static

Initial value:

= {
    [ACPI_SERIAL_TYPE_I2C] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(i2c),
    [ACPI_SERIAL_TYPE_SPI] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(spi),
    [ACPI_SERIAL_TYPE_UART] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(uart),
    [ACPI_SERIAL_TYPE_CSI2] = NATIVE_SERIAL_RESOURCE_EXTRA_SIZE(csi2),
}

Definition at line 541 of file resources.c.

Referenced by do_aml_resource_to_native(), do_native_resource_to_aml(), and extra_size_for_serial_connection().

◆ convert_address64_extended

const struct uacpi_resource_convert_instruction convert_address64_extended[]

static

Initial value:

= {
    CONVERT_GENERAL_ADDRESS_FLAGS(address64_extended),
    OP(FIELD_8, AML_F(address64_extended, revision_id),
       NATIVE_F(address64_extended, revision_id)),
    OP(FIELD_64, AML_F(address64_extended, granularity),
       NATIVE_F(address64_extended, granularity), IMM(6)),
    CONVERT_TYPE_SPECIFIC_FLAGS(address64_extended),
}

Definition at line 802 of file resources.c.

◆ convert_clock_input

const struct uacpi_resource_convert_instruction convert_clock_input[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(clock_input, revision_id),
       NATIVE_F(clock_input, revision_id)),
    OP(BIT_FIELD_1, AML_F(clock_input, flags), NATIVE_F(clock_input, frequency),
       IMM(0)),
    OP(BIT_FIELD_2, AML_F(clock_input, flags), NATIVE_F(clock_input, scale),
       IMM(1)),
    OP(FIELD_16, AML_F(clock_input, divisor), NATIVE_F(clock_input, divisor)),
    OP(FIELD_32, AML_F(clock_input, numerator), NATIVE_F(clock_input, numerator)),
    OP(FIELD_8, AML_F(clock_input, source_index), NATIVE_F(clock_input, source.index)),
    OP(RESOURCE_SOURCE_NO_INDEX, NATIVE_F(clock_input, source)),
    END(),
}

Definition at line 832 of file resources.c.

◆ convert_dma

const struct uacpi_resource_convert_instruction convert_dma[]

static

Initial value:

= {
    OP(PACKED_ARRAY_8, AML_F(dma, channel_mask), NATIVE_F(dma, channels),
       ARG2(NATIVE_O(dma, num_channels))),
    OP(BIT_FIELD_2, AML_F(dma, flags), NATIVE_F(dma, transfer_type), IMM(0)),
    OP(BIT_FIELD_1, AML_F(dma, flags), NATIVE_F(dma, bus_master_status), IMM(2)),
    OP(BIT_FIELD_2, AML_F(dma, flags), NATIVE_F(dma, channel_speed), IMM(5)),
    END(),
}

Definition at line 632 of file resources.c.

◆ convert_extended_irq

const struct uacpi_resource_convert_instruction convert_extended_irq[]

static

Initial value:

= {
    OP(BIT_FIELD_1, AML_F(extended_irq, flags),
                    NATIVE_F(extended_irq, direction), IMM(0)),
    OP(BIT_FIELD_1, AML_F(extended_irq, flags),
                    NATIVE_F(extended_irq, triggering), IMM(1)),
    OP(BIT_FIELD_1, AML_F(extended_irq, flags),
                    NATIVE_F(extended_irq, polarity), IMM(2)),
    OP(BIT_FIELD_1, AML_F(extended_irq, flags),
                    NATIVE_F(extended_irq, sharing), IMM(3)),
    OP(BIT_FIELD_1, AML_F(extended_irq, flags),
                    NATIVE_F(extended_irq, wake_capability), IMM(4)),
    OP(LOAD_8_STORE, AML_F(extended_irq, num_irqs),
       NATIVE_F(extended_irq, num_irqs), IMM(4)),
    OP(RESOURCE_SOURCE, NATIVE_F(extended_irq, source)),
 
    
    OP(FIELD_8, AML_F(extended_irq, irqs), NATIVE_F(extended_irq, irqs)),
    END(),
}

Definition at line 812 of file resources.c.

◆ convert_fixed_dma

const struct uacpi_resource_convert_instruction convert_fixed_dma[]

static

Initial value:

= {
    OP(FIELD_16, AML_F(fixed_dma, request_line),
                 NATIVE_F(fixed_dma, request_line)),
    OP(FIELD_16, AML_F(fixed_dma, channel), NATIVE_F(fixed_dma, channel)),
    OP(FIELD_8, AML_F(fixed_dma, transfer_width),
                NATIVE_F(fixed_dma, transfer_width)),
    END(),
}

Definition at line 685 of file resources.c.

◆ convert_fixed_io

const struct uacpi_resource_convert_instruction convert_fixed_io[]

static

Initial value:

= {
    OP(FIELD_16, AML_F(fixed_io, address), NATIVE_F(fixed_io, address)),
    OP(FIELD_8, AML_F(fixed_io, length), NATIVE_F(fixed_io, length)),
    END(),
}

Definition at line 679 of file resources.c.

◆ convert_fixed_memory32

const struct uacpi_resource_convert_instruction convert_fixed_memory32[]

static

Initial value:

= {
    OP(BIT_FIELD_1, AML_F(fixed_memory32, information),
                    NATIVE_F(fixed_memory32, write_status), IMM(0)),
    OP(FIELD_32, AML_F(fixed_memory32, address),
                 NATIVE_F(fixed_memory32, address)),
    OP(FIELD_32, AML_F(fixed_memory32, length),
                 NATIVE_F(fixed_memory32, length)),
    END(),
}

Definition at line 721 of file resources.c.

◆ convert_generic_register

const struct uacpi_resource_convert_instruction convert_generic_register[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(generic_register, address_space_id),
                NATIVE_F(generic_register, address_space_id), IMM(4)),
    OP(FIELD_64, AML_F(generic_register, address),
                NATIVE_F(generic_register, address)),
    END(),
}

Definition at line 732 of file resources.c.

◆ convert_generic_serial_bus

const struct uacpi_resource_convert_instruction convert_generic_serial_bus[]

static

Definition at line 992 of file resources.c.

◆ convert_gpio_connection

const struct uacpi_resource_convert_instruction convert_gpio_connection[]

static

Definition at line 866 of file resources.c.

◆ convert_io

const struct uacpi_resource_convert_instruction convert_io[]

static

Initial value:

= {
    OP(BIT_FIELD_1, AML_F(io, information), NATIVE_F(io, decode_type)),
    OP(FIELD_16, AML_F(io, minimum), NATIVE_F(io, minimum)),
    OP(FIELD_16, AML_F(io, maximum), NATIVE_F(io, maximum)),
    OP(FIELD_8, AML_F(io, alignment), NATIVE_F(io, alignment)),
    OP(FIELD_8, AML_F(io, length), NATIVE_F(io, length)),
    END(),
}

Definition at line 670 of file resources.c.

◆ convert_irq_to_aml

const struct uacpi_resource_convert_instruction convert_irq_to_aml[]

Initial value:

= {
    OP(PACKED_ARRAY_16, AML_F(irq, irq_mask), NATIVE_F(irq, irqs),
       ARG2(NATIVE_O(irq, num_irqs))),
    OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(3), IMM(4)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, triggering), IMM(0)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, polarity), IMM(3)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, sharing), IMM(4)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, wake_capability), IMM(5)),
    END(),
}

Definition at line 621 of file resources.c.

◆ convert_irq_to_native

const struct uacpi_resource_convert_instruction convert_irq_to_native[]

static

Initial value:

= {
    OP(PACKED_ARRAY_16, AML_F(irq, irq_mask), NATIVE_F(irq, irqs),
       ARG2(NATIVE_O(irq, num_irqs))),
    OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(3), IMM(6)),
        OP(SET_TO_IMM, NATIVE_F(irq, length_kind),
           IMM(UACPI_RESOURCE_LENGTH_KIND_FULL)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, triggering), IMM(0)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, polarity), IMM(3)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, sharing), IMM(4)),
        OP(BIT_FIELD_1, AML_F(irq, flags), NATIVE_F(irq, wake_capability), IMM(5)),
        END(),
    OP(SET_TO_IMM, NATIVE_F(irq, length_kind),
       IMM(UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)),
    OP(SET_TO_IMM, NATIVE_F(irq, triggering), IMM(UACPI_TRIGGERING_EDGE)),
    END(),
}

Definition at line 604 of file resources.c.

◆ convert_memory24

const struct uacpi_resource_convert_instruction convert_memory24[]

static

Initial value:

= {
    OP(BIT_FIELD_1, AML_F(memory24, information),
                    NATIVE_F(memory24, write_status), IMM(0)),
    OP(FIELD_16, AML_F(memory24, minimum), NATIVE_F(memory24, minimum), IMM(4)),
    END(),
}

Definition at line 706 of file resources.c.

◆ convert_memory32

const struct uacpi_resource_convert_instruction convert_memory32[]

static

Initial value:

= {
    OP(BIT_FIELD_1, AML_F(memory32, information),
                    NATIVE_F(memory32, write_status), IMM(0)),
    OP(FIELD_32, AML_F(memory32, minimum), NATIVE_F(memory32, minimum), IMM(4)),
    END(),
}

Definition at line 713 of file resources.c.

◆ convert_pin_configuration

const struct uacpi_resource_convert_instruction convert_pin_configuration[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(pin_configuration, revision_id),
       NATIVE_F(pin_configuration, revision_id)),
    OP(BIT_FIELD_1, AML_F(pin_configuration, flags),
       NATIVE_F(pin_configuration, sharing), IMM(0)),
    OP(BIT_FIELD_1, AML_F(pin_configuration, flags),
       NATIVE_F(pin_configuration, direction), IMM(1)),
    OP(FIELD_8, AML_F(pin_configuration, type),
       NATIVE_F(pin_configuration, type)),
    OP(FIELD_32, AML_F(pin_configuration, value),
       NATIVE_F(pin_configuration, value)),
    DECODE_SOURCE_INDEX(pin_configuration),
    DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
        pin_configuration, SOURCE_NO_INDEX, source_offset, source
    ),
    END(),
}

Definition at line 919 of file resources.c.

◆ convert_pin_function

const struct uacpi_resource_convert_instruction convert_pin_function[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(pin_function, revision_id),
       NATIVE_F(pin_function, revision_id)),
    OP(BIT_FIELD_1, AML_F(pin_function, flags),
       NATIVE_F(pin_function, sharing), IMM(0)),
    OP(FIELD_8, AML_F(pin_function, pull_configuration),
       NATIVE_F(pin_function, pull_configuration)),
    OP(FIELD_16, AML_F(pin_function, function_number),
       NATIVE_F(pin_function, function_number)),
    DECODE_SOURCE_INDEX(pin_function),
    DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
        pin_function, SOURCE_NO_INDEX, source_offset, source
    ),
    END(),
}

Definition at line 902 of file resources.c.

◆ convert_pin_group

const struct uacpi_resource_convert_instruction convert_pin_group[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(pin_group, revision_id),
       NATIVE_F(pin_group, revision_id)),
    OP(BIT_FIELD_1, AML_F(pin_group, flags),
       NATIVE_F(pin_group, direction), IMM(0)),
    DECODE_RES_PIN_TBL_AND_VENDOR_DATA(
        pin_group, LABEL, source_lable_offset, label
    ),
    END(),
}

Definition at line 937 of file resources.c.

◆ convert_pin_group_configuration

const struct uacpi_resource_convert_instruction convert_pin_group_configuration[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(pin_group_configuration, revision_id),
       NATIVE_F(pin_group_configuration, revision_id)),
    OP(BIT_FIELD_1, AML_F(pin_group_configuration, flags),
       NATIVE_F(pin_group_configuration, sharing), IMM(0)),
    OP(BIT_FIELD_1, AML_F(pin_group_configuration, flags),
       NATIVE_F(pin_group_configuration, direction), IMM(1)),
    OP(FIELD_8, AML_F(pin_group_configuration, type),
       NATIVE_F(pin_group_configuration, type)),
    OP(FIELD_32, AML_F(pin_group_configuration, value),
       NATIVE_F(pin_group_configuration, value)),
    DECODE_PIN_GROUP_RES_SOURCES(configuration),
    END(),
}

Definition at line 976 of file resources.c.

◆ convert_pin_group_function

const struct uacpi_resource_convert_instruction convert_pin_group_function[]

static

Initial value:

= {
    OP(FIELD_8, AML_F(pin_group_function, revision_id),
       NATIVE_F(pin_group_function, revision_id)),
    OP(BIT_FIELD_1, AML_F(pin_group_function, flags),
       NATIVE_F(pin_group_function, sharing), IMM(0)),
    OP(BIT_FIELD_1, AML_F(pin_group_function, flags),
       NATIVE_F(pin_group_function, direction), IMM(1)),
    OP(FIELD_16, AML_F(pin_group_function, function),
       NATIVE_F(pin_group_function, function)),
    DECODE_PIN_GROUP_RES_SOURCES(function),
    END(),
}

Definition at line 962 of file resources.c.

◆ convert_start_dependent_to_aml

const struct uacpi_resource_convert_instruction convert_start_dependent_to_aml[]

static

Initial value:

= {
    OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(1), IMM(1)),
        OP(BIT_FIELD_2, AML_F(start_dependent, flags),
           NATIVE_F(start_dependent, compatibility), IMM(0)),
        OP(BIT_FIELD_2, AML_F(start_dependent, flags),
           NATIVE_F(start_dependent, performance), IMM(2)),
    END(),
}

Definition at line 661 of file resources.c.

◆ convert_start_dependent_to_native

const struct uacpi_resource_convert_instruction convert_start_dependent_to_native[]

static

Initial value:

= {
    OP(SKIP_IF_AML_SIZE_LESS_THAN, ARG0(1), IMM(4)),
        OP(SET_TO_IMM, NATIVE_F(start_dependent, length_kind),
           IMM(UACPI_RESOURCE_LENGTH_KIND_FULL)),
        OP(BIT_FIELD_2, AML_F(start_dependent, flags),
           NATIVE_F(start_dependent, compatibility), IMM(0)),
        OP(BIT_FIELD_2, AML_F(start_dependent, flags),
           NATIVE_F(start_dependent, performance), IMM(2)),
        END(),
    OP(SET_TO_IMM, NATIVE_F(start_dependent, length_kind),
       IMM(UACPI_RESOURCE_LENGTH_KIND_ONE_LESS)),
    OP(SET_TO_IMM, NATIVE_F(start_dependent, compatibility),
       IMM(UACPI_ACCEPTABLE)),
    OP(SET_TO_IMM, NATIVE_F(start_dependent, performance),
       IMM(UACPI_ACCEPTABLE)),
    END(),
}

Definition at line 642 of file resources.c.

◆ convert_vendor_type0

const struct uacpi_resource_convert_instruction convert_vendor_type0[]

static

Initial value:

= {
    OP(LOAD_AML_SIZE_32, NATIVE_F(vendor, length)),
    OP(FIELD_8, AML_F(vendor_defined_type0, byte_data), NATIVE_F(vendor, data)),
    END(),
}

Definition at line 694 of file resources.c.

◆ convert_vendor_type1

const struct uacpi_resource_convert_instruction convert_vendor_type1[]

static

Initial value:

= {
    OP(LOAD_AML_SIZE_32, NATIVE_F(vendor, length)),
    OP(FIELD_8, AML_F(vendor_defined_type1, byte_data), NATIVE_F(vendor, data)),
    END(),
}

Definition at line 700 of file resources.c.

◆ native_resource_to_type

const uacpi_u8 native_resource_to_type[UACPI_RESOURCE_TYPE_MAX+1]

static

Definition at line 84 of file resources.c.

Referenced by resource_spec_from_native().

◆ type_to_aml_resource

const uacpi_u8 type_to_aml_resource[]

static

Definition at line 52 of file resources.c.

Referenced by do_native_resource_to_aml().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ AML_F

◆ AML_O

◆ AML_SERIAL_RESOURCE_EXTRA_SIZE

◆ ARG0

◆ ARG1

◆ ARG2

◆ CHECK_AML_OFFSET

◆ CHECK_AML_OFFSET_BASE

◆ CHECK_AML_OOB

◆ CONVERSION_OPCODES_COMMON

◆ CONVERT_GENERAL_ADDRESS_FLAGS

◆ CONVERT_TYPE_SPECIFIC_FLAGS

◆ DECODE_PIN_GROUP_RES_SOURCES

◆ DECODE_RES_PIN_TBL_AND_VENDOR_DATA

◆ DECODE_SOURCE_INDEX

◆ DEFINE_ADDRESS_CONVERSION

◆ DEFINE_LARGE_AML_RESOURCE

◆ DEFINE_SMALL_AML_RESOURCE

◆ DEFINE_SMALL_AML_RESOURCE_NO_NATIVE_REPR

◆ END

◆ IMM

◆ INLINE_END_TAG

◆ L

◆ LARGE_ITEM_HEADER_SIZE

◆ LARGE_RESOURCE_BASE

◆ NATIVE_F

◆ NATIVE_FIELD

◆ NATIVE_O

◆ NATIVE_OFFSET

◆ NATIVE_RESOURCE_HEADER_SIZE

◆ NATIVE_SERIAL_RESOURCE_EXTRA_SIZE

◆ OP

◆ PTR_AT

◆ SMALL_ITEM_HEADER_SIZE

Function Documentation

◆ accumulate_aml_buffer_size()

◆ accumulate_native_buffer_size()

◆ aml_serial_to_native_type()

◆ aml_size_for_native_resource()

◆ aml_size_for_serial_connection()

◆ aml_size_with_header()

◆ conditional_continue()

◆ do_aml_resource_to_native()

◆ do_native_resource_to_aml()

◆ eval_resource_helper()

◆ extra_size_for_extended_irq()

◆ extra_size_for_native_address_or_clock_input()

◆ extra_size_for_native_gpio_or_pins()

◆ extra_size_for_native_irq_or_dma()

◆ extra_size_for_native_pin_group()

◆ extra_size_for_native_vendor()

◆ extra_size_for_resource_source()

◆ extra_size_for_serial_connection()

◆ extract_native_resources_from_method()

◆ find_end()

◆ get_aml_resource_size()

◆ get_aml_resource_type()

◆ native_resources_to_aml()

◆ native_size_for_aml_resource()

◆ resource_spec_from_native()

◆ size_for_aml_address_or_clock_input()

◆ size_for_aml_extended_irq()

◆ size_for_aml_gpio_or_pins()

◆ size_for_aml_irq()

◆ size_for_aml_pin_group()

◆ size_for_aml_resource_source()

◆ size_for_aml_start_dependent()

◆ size_for_aml_vendor()

◆ uacpi_find_aml_resource_end_tag()

◆ uacpi_for_each_aml_resource()

◆ uacpi_for_each_device_resource()

◆ uacpi_for_each_resource()

◆ uacpi_free_resource()

◆ uacpi_free_resources()

◆ uacpi_get_current_resources()