resources.c File Reference

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

Go to the source code of this file.

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)    .f1.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)    .f2.native_offset = NATIVE_O(short_native_name, field)
#define	IMM(value)   .f3.imm = value
#define	ARG0(value)   .f1.arg0 = (value)
#define	ARG1(value)   .f2.arg1 = (value)
#define	ARG2(value)   .f3.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)

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
	)		.f1.aml_offset = AML_O(short_aml_name, field)

Definition at line 591 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 588 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))

Definition at line 527 of file resources.c.

ARG0

#define ARG0

(

value

)

.f1.arg0 = (value)

Definition at line 601 of file resources.c.

ARG1

#define ARG1

(

value

)

.f2.arg1 = (value)

Definition at line 602 of file resources.c.

ARG2

#define ARG2

(

value

)

.f3.arg2 = (value)

Definition at line 603 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)

Definition at line 1663 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",       \
            (uacpi_size)offset, base_aml_size_with_header);             \
        ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;                    \
        return UACPI_ITERATION_DECISION_BREAK;                          \
    }

Definition at line 1654 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",                         \
                    (uacpi_size)offset, (uacpi_u32)aml_size + header_size);  \
        ctx->st = UACPI_STATUS_AML_INVALID_RESOURCE;                         \
        return UACPI_ITERATION_DECISION_BREAK;                               \
    }

Definition at line 1646 of file resources.c.

CONVERSION_OPCODES_COMMON

#define CONVERSION_OPCODES_COMMON

(

native_buf

)

Definition at line 1572 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 775 of file resources.c.

CONVERT_TYPE_SPECIFIC_FLAGS

#define CONVERT_TYPE_SPECIFIC_FLAGS

(

addr_type

)

Definition at line 742 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 950 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 852 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))       \

Definition at line 848 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 789 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 1086 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 1063 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 1074 of file resources.c.

END

#define END

(

)

OP(END)

Definition at line 586 of file resources.c.

IMM

#define IMM

(

value

)

.f3.imm = value

Definition at line 600 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
	)		.f2.native_offset = NATIVE_O(short_native_name, field)

Definition at line 597 of file resources.c.

NATIVE_FIELD

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

Definition at line 1643 of file resources.c.

NATIVE_O

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

Definition at line 594 of file resources.c.

NATIVE_OFFSET

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

Definition at line 1640 of file resources.c.

NATIVE_RESOURCE_HEADER_SIZE

#define NATIVE_RESOURCE_HEADER_SIZE   8

Definition at line 1061 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))

Definition at line 531 of file resources.c.

OP

#define OP	(		short_code,
			...
	)

Value:

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

Definition at line 580 of file resources.c.

PTR_AT

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

Definition at line 1638 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 2472 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",
                    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 1942 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",
                    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 1667 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 2182 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 565 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 1563 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 1675 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->f1.aml_offset;
        dst = NATIVE_OFFSET(resource, insn->f2.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->f3.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->f3.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 = { 0 };
 
            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->f3.arg2) {
                uacpi_memcpy_zerout(&max_offset, data + insn->f3.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");
                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->f3.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->f3.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", 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 2191 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->f2.native_offset);
        dst = dst_base + insn->f1.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->f3.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->f3.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 = { 0 };
 
            src_name.ptr = src;
 
            source_offset = base_aml_size_with_header + accumulator;
            dst_string = dst_base + source_offset;
 
            if (insn->f1.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",
                    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->f3.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",
                        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",
                    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 1962 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 329 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 292 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 358 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_u16 mask;
    uacpi_u8 i, total_bits, num_bits = 0;
 
    UACPI_UNUSED(size);
 
    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 464 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 221 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 257 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 551 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 2074 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 1501 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 1382 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 1369 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 2447 of file resources.c.

{
    uacpi_status ret;
    struct resource_conversion_ctx ctx = { 0 };
 
    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
        uacpi_resource end_tag = { .type = UACPI_RESOURCE_TYPE_END_TAG };
 
        do_native_resource_to_aml(&ctx, &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 1516 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 2175 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 300 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 344 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 413 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 156 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");
    }
 
    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 491 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 273 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", 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 190 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");
    }
 
    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 230 of file resources.c.

{
    uacpi_size size = resource->vendor.length;
 
    UACPI_UNUSED(spec);
 
    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", 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 1528 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 1425 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
	)

A shorthand for uacpi_get_device_resources() + uacpi_for_each_resource().

Use if you don't actually want to save the 'resources' list, but simply want to iterate it once to extract the resources you care about and then free it right away.

Definition at line 2157 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
	)

A convenience helper for iterating over the resource list returned by any of the uacpi_get_*_resources functions.

Definition at line 2117 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",
                        resources, resources->length);
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        if (uacpi_unlikely(current->type > UACPI_RESOURCE_TYPE_MAX)) {
            uacpi_error("invalid resource type %d", current->type);
            return UACPI_STATUS_INVALID_ARGUMENT;
        }
 
        if (uacpi_unlikely(current->length > bytes_left)) {
            uacpi_error("corrupted resource@%p length %u (%zu bytes left)",
                        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 2066 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 2058 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
	)

Evaluate the _CRS method for a 'device' and get the returned resource list via 'out_resources'.

NOTE: the returned buffer must be released via uacpi_free_resources()

If you don't need to keep the resource array for later use you can uacpi_for_each_device_resource(device, "_CRS", ...) instead, which takes care of iteration & memory management on its own.

Definition at line 2095 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
	)

Evaluate an arbitrary method that is expected to return an AML resource buffer for a 'device' and get the returned resource list via 'out_resources'.

NOTE: the returned buffer must be released via uacpi_free_resources()

If you don't need to keep the resource array for later use you can uacpi_for_each_device_resource(device, method, ...) instead, which takes care of iteration & memory management on its own.

Definition at line 2109 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
	)

Evaluate the _PRS method for a 'device' and get the returned resource list via 'out_resources'.

NOTE: the returned buffer must be released via uacpi_free_resources()

If you don't need to keep the resource array for later use you can uacpi_for_each_device_resource(device, "_PRS", ...) instead, which takes care of iteration & memory management on its own.

Definition at line 2102 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
	)

Convert a single AML-encoded resource to native format.

This should be used for converting Connection() fields (passed during IO on GeneralPurposeIO or GenericSerialBus operation regions) or other similar buffers with only one resource to native format.

NOTE: the returned buffer must be released via uacpi_free_resource()

Definition at line 2024 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;
 
    uacpi_memzero(&ctx, sizeof(ctx));
    ctx.buf = resource;
    ctx.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 1982 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", 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));
 
    uacpi_memzero(&ctx, sizeof(ctx));
    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 2495 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
        uacpi_resource end_tag = { .type = UACPI_RESOURCE_TYPE_END_TAG };
 
        accumulate_aml_buffer_size(&ctx, &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", 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
	)

Set the configuration to be used by the 'device' by calling its _SRS method.

Note that this expects 'resources' in the normal 'uacpi_resources' format, and not the raw AML resources bytestream, the conversion to the latter is done automatically by this API. If you want to _SRS a raw AML resources bytestream, use 'uacpi_execute' or similar API directly.

Definition at line 2548 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 1414 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", 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 1097 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 535 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 543 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 804 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 834 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 634 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 814 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 687 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 681 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 723 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 734 of file resources.c.

convert_generic_serial_bus

const struct uacpi_resource_convert_instruction convert_generic_serial_bus[]

static

Definition at line 994 of file resources.c.

convert_gpio_connection

const struct uacpi_resource_convert_instruction convert_gpio_connection[]

static

Definition at line 868 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 672 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 623 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 606 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 708 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 715 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 921 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 904 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 939 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 978 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 964 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 663 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 644 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 696 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 702 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().