forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762 lines
20 KiB
762 lines
20 KiB
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
|
/****************************************************************************** |
|
* |
|
* Module Name: dsopcode - Dispatcher support for regions and fields |
|
* |
|
* Copyright (C) 2000 - 2021, Intel Corp. |
|
* |
|
*****************************************************************************/ |
|
|
|
#include <acpi/acpi.h> |
|
#include "accommon.h" |
|
#include "acparser.h" |
|
#include "amlcode.h" |
|
#include "acdispat.h" |
|
#include "acinterp.h" |
|
#include "acnamesp.h" |
|
#include "acevents.h" |
|
#include "actables.h" |
|
|
|
#define _COMPONENT ACPI_DISPATCHER |
|
ACPI_MODULE_NAME("dsopcode") |
|
|
|
/* Local prototypes */ |
|
static acpi_status |
|
acpi_ds_init_buffer_field(u16 aml_opcode, |
|
union acpi_operand_object *obj_desc, |
|
union acpi_operand_object *buffer_desc, |
|
union acpi_operand_object *offset_desc, |
|
union acpi_operand_object *length_desc, |
|
union acpi_operand_object *result_desc); |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_initialize_region |
|
* |
|
* PARAMETERS: obj_handle - Region namespace node |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Front end to ev_initialize_region |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status acpi_ds_initialize_region(acpi_handle obj_handle) |
|
{ |
|
union acpi_operand_object *obj_desc; |
|
acpi_status status; |
|
|
|
obj_desc = acpi_ns_get_attached_object(obj_handle); |
|
|
|
/* Namespace is NOT locked */ |
|
|
|
status = acpi_ev_initialize_region(obj_desc); |
|
return (status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_init_buffer_field |
|
* |
|
* PARAMETERS: aml_opcode - create_xxx_field |
|
* obj_desc - buffer_field object |
|
* buffer_desc - Host Buffer |
|
* offset_desc - Offset into buffer |
|
* length_desc - Length of field (CREATE_FIELD_OP only) |
|
* result_desc - Where to store the result |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Perform actual initialization of a buffer field |
|
* |
|
******************************************************************************/ |
|
|
|
static acpi_status |
|
acpi_ds_init_buffer_field(u16 aml_opcode, |
|
union acpi_operand_object *obj_desc, |
|
union acpi_operand_object *buffer_desc, |
|
union acpi_operand_object *offset_desc, |
|
union acpi_operand_object *length_desc, |
|
union acpi_operand_object *result_desc) |
|
{ |
|
u32 offset; |
|
u32 bit_offset; |
|
u32 bit_count; |
|
u8 field_flags; |
|
acpi_status status; |
|
|
|
ACPI_FUNCTION_TRACE_PTR(ds_init_buffer_field, obj_desc); |
|
|
|
/* Host object must be a Buffer */ |
|
|
|
if (buffer_desc->common.type != ACPI_TYPE_BUFFER) { |
|
ACPI_ERROR((AE_INFO, |
|
"Target of Create Field is not a Buffer object - %s", |
|
acpi_ut_get_object_type_name(buffer_desc))); |
|
|
|
status = AE_AML_OPERAND_TYPE; |
|
goto cleanup; |
|
} |
|
|
|
/* |
|
* The last parameter to all of these opcodes (result_desc) started |
|
* out as a name_string, and should therefore now be a NS node |
|
* after resolution in acpi_ex_resolve_operands(). |
|
*/ |
|
if (ACPI_GET_DESCRIPTOR_TYPE(result_desc) != ACPI_DESC_TYPE_NAMED) { |
|
ACPI_ERROR((AE_INFO, |
|
"(%s) destination not a NS Node [%s]", |
|
acpi_ps_get_opcode_name(aml_opcode), |
|
acpi_ut_get_descriptor_name(result_desc))); |
|
|
|
status = AE_AML_OPERAND_TYPE; |
|
goto cleanup; |
|
} |
|
|
|
offset = (u32) offset_desc->integer.value; |
|
|
|
/* |
|
* Setup the Bit offsets and counts, according to the opcode |
|
*/ |
|
switch (aml_opcode) { |
|
case AML_CREATE_FIELD_OP: |
|
|
|
/* Offset is in bits, count is in bits */ |
|
|
|
field_flags = AML_FIELD_ACCESS_BYTE; |
|
bit_offset = offset; |
|
bit_count = (u32) length_desc->integer.value; |
|
|
|
/* Must have a valid (>0) bit count */ |
|
|
|
if (bit_count == 0) { |
|
ACPI_BIOS_ERROR((AE_INFO, |
|
"Attempt to CreateField of length zero")); |
|
status = AE_AML_OPERAND_VALUE; |
|
goto cleanup; |
|
} |
|
break; |
|
|
|
case AML_CREATE_BIT_FIELD_OP: |
|
|
|
/* Offset is in bits, Field is one bit */ |
|
|
|
bit_offset = offset; |
|
bit_count = 1; |
|
field_flags = AML_FIELD_ACCESS_BYTE; |
|
break; |
|
|
|
case AML_CREATE_BYTE_FIELD_OP: |
|
|
|
/* Offset is in bytes, field is one byte */ |
|
|
|
bit_offset = 8 * offset; |
|
bit_count = 8; |
|
field_flags = AML_FIELD_ACCESS_BYTE; |
|
break; |
|
|
|
case AML_CREATE_WORD_FIELD_OP: |
|
|
|
/* Offset is in bytes, field is one word */ |
|
|
|
bit_offset = 8 * offset; |
|
bit_count = 16; |
|
field_flags = AML_FIELD_ACCESS_WORD; |
|
break; |
|
|
|
case AML_CREATE_DWORD_FIELD_OP: |
|
|
|
/* Offset is in bytes, field is one dword */ |
|
|
|
bit_offset = 8 * offset; |
|
bit_count = 32; |
|
field_flags = AML_FIELD_ACCESS_DWORD; |
|
break; |
|
|
|
case AML_CREATE_QWORD_FIELD_OP: |
|
|
|
/* Offset is in bytes, field is one qword */ |
|
|
|
bit_offset = 8 * offset; |
|
bit_count = 64; |
|
field_flags = AML_FIELD_ACCESS_QWORD; |
|
break; |
|
|
|
default: |
|
|
|
ACPI_ERROR((AE_INFO, |
|
"Unknown field creation opcode 0x%02X", |
|
aml_opcode)); |
|
status = AE_AML_BAD_OPCODE; |
|
goto cleanup; |
|
} |
|
|
|
/* Entire field must fit within the current length of the buffer */ |
|
|
|
if ((bit_offset + bit_count) > (8 * (u32)buffer_desc->buffer.length)) { |
|
status = AE_AML_BUFFER_LIMIT; |
|
ACPI_BIOS_EXCEPTION((AE_INFO, status, |
|
"Field [%4.4s] at bit offset/length %u/%u " |
|
"exceeds size of target Buffer (%u bits)", |
|
acpi_ut_get_node_name(result_desc), |
|
bit_offset, bit_count, |
|
8 * (u32)buffer_desc->buffer.length)); |
|
goto cleanup; |
|
} |
|
|
|
/* |
|
* Initialize areas of the field object that are common to all fields |
|
* For field_flags, use LOCK_RULE = 0 (NO_LOCK), |
|
* UPDATE_RULE = 0 (UPDATE_PRESERVE) |
|
*/ |
|
status = |
|
acpi_ex_prep_common_field_object(obj_desc, field_flags, 0, |
|
bit_offset, bit_count); |
|
if (ACPI_FAILURE(status)) { |
|
goto cleanup; |
|
} |
|
|
|
obj_desc->buffer_field.buffer_obj = buffer_desc; |
|
obj_desc->buffer_field.is_create_field = |
|
aml_opcode == AML_CREATE_FIELD_OP; |
|
|
|
/* Reference count for buffer_desc inherits obj_desc count */ |
|
|
|
buffer_desc->common.reference_count = (u16) |
|
(buffer_desc->common.reference_count + |
|
obj_desc->common.reference_count); |
|
|
|
cleanup: |
|
|
|
/* Always delete the operands */ |
|
|
|
acpi_ut_remove_reference(offset_desc); |
|
acpi_ut_remove_reference(buffer_desc); |
|
|
|
if (aml_opcode == AML_CREATE_FIELD_OP) { |
|
acpi_ut_remove_reference(length_desc); |
|
} |
|
|
|
/* On failure, delete the result descriptor */ |
|
|
|
if (ACPI_FAILURE(status)) { |
|
acpi_ut_remove_reference(result_desc); /* Result descriptor */ |
|
} else { |
|
/* Now the address and length are valid for this buffer_field */ |
|
|
|
obj_desc->buffer_field.flags |= AOPOBJ_DATA_VALID; |
|
} |
|
|
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_eval_buffer_field_operands |
|
* |
|
* PARAMETERS: walk_state - Current walk |
|
* op - A valid buffer_field Op object |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Get buffer_field Buffer and Index |
|
* Called from acpi_ds_exec_end_op during buffer_field parse tree walk |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status |
|
acpi_ds_eval_buffer_field_operands(struct acpi_walk_state *walk_state, |
|
union acpi_parse_object *op) |
|
{ |
|
acpi_status status; |
|
union acpi_operand_object *obj_desc; |
|
struct acpi_namespace_node *node; |
|
union acpi_parse_object *next_op; |
|
|
|
ACPI_FUNCTION_TRACE_PTR(ds_eval_buffer_field_operands, op); |
|
|
|
/* |
|
* This is where we evaluate the address and length fields of the |
|
* create_xxx_field declaration |
|
*/ |
|
node = op->common.node; |
|
|
|
/* next_op points to the op that holds the Buffer */ |
|
|
|
next_op = op->common.value.arg; |
|
|
|
/* Evaluate/create the address and length operands */ |
|
|
|
status = acpi_ds_create_operands(walk_state, next_op); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
obj_desc = acpi_ns_get_attached_object(node); |
|
if (!obj_desc) { |
|
return_ACPI_STATUS(AE_NOT_EXIST); |
|
} |
|
|
|
/* Resolve the operands */ |
|
|
|
status = |
|
acpi_ex_resolve_operands(op->common.aml_opcode, ACPI_WALK_OPERANDS, |
|
walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
ACPI_ERROR((AE_INFO, "(%s) bad operand(s), status 0x%X", |
|
acpi_ps_get_opcode_name(op->common.aml_opcode), |
|
status)); |
|
|
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/* Initialize the Buffer Field */ |
|
|
|
if (op->common.aml_opcode == AML_CREATE_FIELD_OP) { |
|
|
|
/* NOTE: Slightly different operands for this opcode */ |
|
|
|
status = |
|
acpi_ds_init_buffer_field(op->common.aml_opcode, obj_desc, |
|
walk_state->operands[0], |
|
walk_state->operands[1], |
|
walk_state->operands[2], |
|
walk_state->operands[3]); |
|
} else { |
|
/* All other, create_xxx_field opcodes */ |
|
|
|
status = |
|
acpi_ds_init_buffer_field(op->common.aml_opcode, obj_desc, |
|
walk_state->operands[0], |
|
walk_state->operands[1], NULL, |
|
walk_state->operands[2]); |
|
} |
|
|
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_eval_region_operands |
|
* |
|
* PARAMETERS: walk_state - Current walk |
|
* op - A valid region Op object |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Get region address and length |
|
* Called from acpi_ds_exec_end_op during op_region parse tree walk |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status |
|
acpi_ds_eval_region_operands(struct acpi_walk_state *walk_state, |
|
union acpi_parse_object *op) |
|
{ |
|
acpi_status status; |
|
union acpi_operand_object *obj_desc; |
|
union acpi_operand_object *operand_desc; |
|
struct acpi_namespace_node *node; |
|
union acpi_parse_object *next_op; |
|
acpi_adr_space_type space_id; |
|
|
|
ACPI_FUNCTION_TRACE_PTR(ds_eval_region_operands, op); |
|
|
|
/* |
|
* This is where we evaluate the address and length fields of the |
|
* op_region declaration |
|
*/ |
|
node = op->common.node; |
|
|
|
/* next_op points to the op that holds the space_ID */ |
|
|
|
next_op = op->common.value.arg; |
|
space_id = (acpi_adr_space_type)next_op->common.value.integer; |
|
|
|
/* next_op points to address op */ |
|
|
|
next_op = next_op->common.next; |
|
|
|
/* Evaluate/create the address and length operands */ |
|
|
|
status = acpi_ds_create_operands(walk_state, next_op); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/* Resolve the length and address operands to numbers */ |
|
|
|
status = |
|
acpi_ex_resolve_operands(op->common.aml_opcode, ACPI_WALK_OPERANDS, |
|
walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
obj_desc = acpi_ns_get_attached_object(node); |
|
if (!obj_desc) { |
|
return_ACPI_STATUS(AE_NOT_EXIST); |
|
} |
|
|
|
/* |
|
* Get the length operand and save it |
|
* (at Top of stack) |
|
*/ |
|
operand_desc = walk_state->operands[walk_state->num_operands - 1]; |
|
|
|
obj_desc->region.length = (u32) operand_desc->integer.value; |
|
acpi_ut_remove_reference(operand_desc); |
|
|
|
/* A zero-length operation region is unusable. Just warn */ |
|
|
|
if (!obj_desc->region.length |
|
&& (space_id < ACPI_NUM_PREDEFINED_REGIONS)) { |
|
ACPI_WARNING((AE_INFO, |
|
"Operation Region [%4.4s] has zero length (SpaceId %X)", |
|
node->name.ascii, space_id)); |
|
} |
|
|
|
/* |
|
* Get the address and save it |
|
* (at top of stack - 1) |
|
*/ |
|
operand_desc = walk_state->operands[walk_state->num_operands - 2]; |
|
|
|
obj_desc->region.address = (acpi_physical_address) |
|
operand_desc->integer.value; |
|
acpi_ut_remove_reference(operand_desc); |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n", |
|
obj_desc, |
|
ACPI_FORMAT_UINT64(obj_desc->region.address), |
|
obj_desc->region.length)); |
|
|
|
status = acpi_ut_add_address_range(obj_desc->region.space_id, |
|
obj_desc->region.address, |
|
obj_desc->region.length, node); |
|
|
|
/* Now the address and length are valid for this opregion */ |
|
|
|
obj_desc->region.flags |= AOPOBJ_DATA_VALID; |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_eval_table_region_operands |
|
* |
|
* PARAMETERS: walk_state - Current walk |
|
* op - A valid region Op object |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Get region address and length. |
|
* Called from acpi_ds_exec_end_op during data_table_region parse |
|
* tree walk. |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status |
|
acpi_ds_eval_table_region_operands(struct acpi_walk_state *walk_state, |
|
union acpi_parse_object *op) |
|
{ |
|
acpi_status status; |
|
union acpi_operand_object *obj_desc; |
|
union acpi_operand_object **operand; |
|
struct acpi_namespace_node *node; |
|
union acpi_parse_object *next_op; |
|
struct acpi_table_header *table; |
|
u32 table_index; |
|
|
|
ACPI_FUNCTION_TRACE_PTR(ds_eval_table_region_operands, op); |
|
|
|
/* |
|
* This is where we evaluate the Signature string, oem_id string, |
|
* and oem_table_id string of the Data Table Region declaration |
|
*/ |
|
node = op->common.node; |
|
|
|
/* next_op points to Signature string op */ |
|
|
|
next_op = op->common.value.arg; |
|
|
|
/* |
|
* Evaluate/create the Signature string, oem_id string, |
|
* and oem_table_id string operands |
|
*/ |
|
status = acpi_ds_create_operands(walk_state, next_op); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
operand = &walk_state->operands[0]; |
|
|
|
/* |
|
* Resolve the Signature string, oem_id string, |
|
* and oem_table_id string operands |
|
*/ |
|
status = |
|
acpi_ex_resolve_operands(op->common.aml_opcode, ACPI_WALK_OPERANDS, |
|
walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
goto cleanup; |
|
} |
|
|
|
/* Find the ACPI table */ |
|
|
|
status = acpi_tb_find_table(operand[0]->string.pointer, |
|
operand[1]->string.pointer, |
|
operand[2]->string.pointer, &table_index); |
|
if (ACPI_FAILURE(status)) { |
|
if (status == AE_NOT_FOUND) { |
|
ACPI_ERROR((AE_INFO, |
|
"ACPI Table [%4.4s] OEM:(%s, %s) not found in RSDT/XSDT", |
|
operand[0]->string.pointer, |
|
operand[1]->string.pointer, |
|
operand[2]->string.pointer)); |
|
} |
|
goto cleanup; |
|
} |
|
|
|
status = acpi_get_table_by_index(table_index, &table); |
|
if (ACPI_FAILURE(status)) { |
|
goto cleanup; |
|
} |
|
|
|
obj_desc = acpi_ns_get_attached_object(node); |
|
if (!obj_desc) { |
|
status = AE_NOT_EXIST; |
|
goto cleanup; |
|
} |
|
|
|
obj_desc->region.address = ACPI_PTR_TO_PHYSADDR(table); |
|
obj_desc->region.length = table->length; |
|
obj_desc->region.pointer = table; |
|
|
|
ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X\n", |
|
obj_desc, |
|
ACPI_FORMAT_UINT64(obj_desc->region.address), |
|
obj_desc->region.length)); |
|
|
|
/* Now the address and length are valid for this opregion */ |
|
|
|
obj_desc->region.flags |= AOPOBJ_DATA_VALID; |
|
|
|
cleanup: |
|
acpi_ut_remove_reference(operand[0]); |
|
acpi_ut_remove_reference(operand[1]); |
|
acpi_ut_remove_reference(operand[2]); |
|
|
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_eval_data_object_operands |
|
* |
|
* PARAMETERS: walk_state - Current walk |
|
* op - A valid data_object Op object |
|
* obj_desc - data_object |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Get the operands and complete the following data object types: |
|
* Buffer, Package. |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status |
|
acpi_ds_eval_data_object_operands(struct acpi_walk_state *walk_state, |
|
union acpi_parse_object *op, |
|
union acpi_operand_object *obj_desc) |
|
{ |
|
acpi_status status; |
|
union acpi_operand_object *arg_desc; |
|
u32 length; |
|
|
|
ACPI_FUNCTION_TRACE(ds_eval_data_object_operands); |
|
|
|
/* The first operand (for all of these data objects) is the length */ |
|
|
|
/* |
|
* Set proper index into operand stack for acpi_ds_obj_stack_push |
|
* invoked inside acpi_ds_create_operand. |
|
*/ |
|
walk_state->operand_index = walk_state->num_operands; |
|
|
|
/* Ignore if child is not valid */ |
|
|
|
if (!op->common.value.arg) { |
|
ACPI_ERROR((AE_INFO, |
|
"Missing child while evaluating opcode %4.4X, Op %p", |
|
op->common.aml_opcode, op)); |
|
return_ACPI_STATUS(AE_OK); |
|
} |
|
|
|
status = acpi_ds_create_operand(walk_state, op->common.value.arg, 1); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
status = acpi_ex_resolve_operands(walk_state->opcode, |
|
&(walk_state-> |
|
operands[walk_state->num_operands - |
|
1]), walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/* Extract length operand */ |
|
|
|
arg_desc = walk_state->operands[walk_state->num_operands - 1]; |
|
length = (u32) arg_desc->integer.value; |
|
|
|
/* Cleanup for length operand */ |
|
|
|
status = acpi_ds_obj_stack_pop(1, walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
acpi_ut_remove_reference(arg_desc); |
|
|
|
/* |
|
* Create the actual data object |
|
*/ |
|
switch (op->common.aml_opcode) { |
|
case AML_BUFFER_OP: |
|
|
|
status = |
|
acpi_ds_build_internal_buffer_obj(walk_state, op, length, |
|
&obj_desc); |
|
break; |
|
|
|
case AML_PACKAGE_OP: |
|
case AML_VARIABLE_PACKAGE_OP: |
|
|
|
status = |
|
acpi_ds_build_internal_package_obj(walk_state, op, length, |
|
&obj_desc); |
|
break; |
|
|
|
default: |
|
|
|
return_ACPI_STATUS(AE_AML_BAD_OPCODE); |
|
} |
|
|
|
if (ACPI_SUCCESS(status)) { |
|
/* |
|
* Return the object in the walk_state, unless the parent is a package - |
|
* in this case, the return object will be stored in the parse tree |
|
* for the package. |
|
*/ |
|
if ((!op->common.parent) || |
|
((op->common.parent->common.aml_opcode != AML_PACKAGE_OP) && |
|
(op->common.parent->common.aml_opcode != |
|
AML_VARIABLE_PACKAGE_OP) |
|
&& (op->common.parent->common.aml_opcode != |
|
AML_NAME_OP))) { |
|
walk_state->result_obj = obj_desc; |
|
} |
|
} |
|
|
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
/******************************************************************************* |
|
* |
|
* FUNCTION: acpi_ds_eval_bank_field_operands |
|
* |
|
* PARAMETERS: walk_state - Current walk |
|
* op - A valid bank_field Op object |
|
* |
|
* RETURN: Status |
|
* |
|
* DESCRIPTION: Get bank_field bank_value |
|
* Called from acpi_ds_exec_end_op during bank_field parse tree walk |
|
* |
|
******************************************************************************/ |
|
|
|
acpi_status |
|
acpi_ds_eval_bank_field_operands(struct acpi_walk_state *walk_state, |
|
union acpi_parse_object *op) |
|
{ |
|
acpi_status status; |
|
union acpi_operand_object *obj_desc; |
|
union acpi_operand_object *operand_desc; |
|
struct acpi_namespace_node *node; |
|
union acpi_parse_object *next_op; |
|
union acpi_parse_object *arg; |
|
|
|
ACPI_FUNCTION_TRACE_PTR(ds_eval_bank_field_operands, op); |
|
|
|
/* |
|
* This is where we evaluate the bank_value field of the |
|
* bank_field declaration |
|
*/ |
|
|
|
/* next_op points to the op that holds the Region */ |
|
|
|
next_op = op->common.value.arg; |
|
|
|
/* next_op points to the op that holds the Bank Register */ |
|
|
|
next_op = next_op->common.next; |
|
|
|
/* next_op points to the op that holds the Bank Value */ |
|
|
|
next_op = next_op->common.next; |
|
|
|
/* |
|
* Set proper index into operand stack for acpi_ds_obj_stack_push |
|
* invoked inside acpi_ds_create_operand. |
|
* |
|
* We use walk_state->Operands[0] to store the evaluated bank_value |
|
*/ |
|
walk_state->operand_index = 0; |
|
|
|
status = acpi_ds_create_operand(walk_state, next_op, 0); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
status = acpi_ex_resolve_to_value(&walk_state->operands[0], walk_state); |
|
if (ACPI_FAILURE(status)) { |
|
return_ACPI_STATUS(status); |
|
} |
|
|
|
ACPI_DUMP_OPERANDS(ACPI_WALK_OPERANDS, |
|
acpi_ps_get_opcode_name(op->common.aml_opcode), 1); |
|
/* |
|
* Get the bank_value operand and save it |
|
* (at Top of stack) |
|
*/ |
|
operand_desc = walk_state->operands[0]; |
|
|
|
/* Arg points to the start Bank Field */ |
|
|
|
arg = acpi_ps_get_arg(op, 4); |
|
while (arg) { |
|
|
|
/* Ignore OFFSET and ACCESSAS terms here */ |
|
|
|
if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) { |
|
node = arg->common.node; |
|
|
|
obj_desc = acpi_ns_get_attached_object(node); |
|
if (!obj_desc) { |
|
return_ACPI_STATUS(AE_NOT_EXIST); |
|
} |
|
|
|
obj_desc->bank_field.value = |
|
(u32) operand_desc->integer.value; |
|
} |
|
|
|
/* Move to next field in the list */ |
|
|
|
arg = arg->common.next; |
|
} |
|
|
|
acpi_ut_remove_reference(operand_desc); |
|
return_ACPI_STATUS(status); |
|
}
|
|
|