1 /******************************************************************************
3 * Module Name: dsopcode - Dispatcher Op Region support and handling of
6 *****************************************************************************/
9 * Copyright (C) 2000 - 2008, Intel Corp.
10 * All rights reserved.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
45 #include <acpi/acpi.h>
46 #include <acpi/acparser.h>
47 #include <acpi/amlcode.h>
48 #include <acpi/acdispat.h>
49 #include <acpi/acinterp.h>
50 #include <acpi/acnamesp.h>
51 #include <acpi/acevents.h>
52 #include <acpi/actables.h>
54 #define _COMPONENT ACPI_DISPATCHER
55 ACPI_MODULE_NAME("dsopcode")
57 /* Local prototypes */
59 acpi_ds_execute_arguments(struct acpi_namespace_node
*node
,
60 struct acpi_namespace_node
*scope_node
,
61 u32 aml_length
, u8
* aml_start
);
64 acpi_ds_init_buffer_field(u16 aml_opcode
,
65 union acpi_operand_object
*obj_desc
,
66 union acpi_operand_object
*buffer_desc
,
67 union acpi_operand_object
*offset_desc
,
68 union acpi_operand_object
*length_desc
,
69 union acpi_operand_object
*result_desc
);
71 /*******************************************************************************
73 * FUNCTION: acpi_ds_execute_arguments
75 * PARAMETERS: Node - Object NS node
76 * scope_node - Parent NS node
77 * aml_length - Length of executable AML
78 * aml_start - Pointer to the AML
82 * DESCRIPTION: Late (deferred) execution of region or field arguments
84 ******************************************************************************/
87 acpi_ds_execute_arguments(struct acpi_namespace_node
*node
,
88 struct acpi_namespace_node
*scope_node
,
89 u32 aml_length
, u8
* aml_start
)
92 union acpi_parse_object
*op
;
93 struct acpi_walk_state
*walk_state
;
95 ACPI_FUNCTION_TRACE(ds_execute_arguments
);
98 * Allocate a new parser op to be the root of the parsed tree
100 op
= acpi_ps_alloc_op(AML_INT_EVAL_SUBTREE_OP
);
102 return_ACPI_STATUS(AE_NO_MEMORY
);
105 /* Save the Node for use in acpi_ps_parse_aml */
107 op
->common
.node
= scope_node
;
109 /* Create and initialize a new parser state */
111 walk_state
= acpi_ds_create_walk_state(0, NULL
, NULL
, NULL
);
113 status
= AE_NO_MEMORY
;
117 status
= acpi_ds_init_aml_walk(walk_state
, op
, NULL
, aml_start
,
118 aml_length
, NULL
, ACPI_IMODE_LOAD_PASS1
);
119 if (ACPI_FAILURE(status
)) {
120 acpi_ds_delete_walk_state(walk_state
);
124 /* Mark this parse as a deferred opcode */
126 walk_state
->parse_flags
= ACPI_PARSE_DEFERRED_OP
;
127 walk_state
->deferred_node
= node
;
129 /* Pass1: Parse the entire declaration */
131 status
= acpi_ps_parse_aml(walk_state
);
132 if (ACPI_FAILURE(status
)) {
136 /* Get and init the Op created above */
138 op
->common
.node
= node
;
139 acpi_ps_delete_parse_tree(op
);
141 /* Evaluate the deferred arguments */
143 op
= acpi_ps_alloc_op(AML_INT_EVAL_SUBTREE_OP
);
145 return_ACPI_STATUS(AE_NO_MEMORY
);
148 op
->common
.node
= scope_node
;
150 /* Create and initialize a new parser state */
152 walk_state
= acpi_ds_create_walk_state(0, NULL
, NULL
, NULL
);
154 status
= AE_NO_MEMORY
;
158 /* Execute the opcode and arguments */
160 status
= acpi_ds_init_aml_walk(walk_state
, op
, NULL
, aml_start
,
161 aml_length
, NULL
, ACPI_IMODE_EXECUTE
);
162 if (ACPI_FAILURE(status
)) {
163 acpi_ds_delete_walk_state(walk_state
);
167 /* Mark this execution as a deferred opcode */
169 walk_state
->deferred_node
= node
;
170 status
= acpi_ps_parse_aml(walk_state
);
173 acpi_ps_delete_parse_tree(op
);
174 return_ACPI_STATUS(status
);
177 /*******************************************************************************
179 * FUNCTION: acpi_ds_get_buffer_field_arguments
181 * PARAMETERS: obj_desc - A valid buffer_field object
185 * DESCRIPTION: Get buffer_field Buffer and Index. This implements the late
186 * evaluation of these field attributes.
188 ******************************************************************************/
191 acpi_ds_get_buffer_field_arguments(union acpi_operand_object
*obj_desc
)
193 union acpi_operand_object
*extra_desc
;
194 struct acpi_namespace_node
*node
;
197 ACPI_FUNCTION_TRACE_PTR(ds_get_buffer_field_arguments
, obj_desc
);
199 if (obj_desc
->common
.flags
& AOPOBJ_DATA_VALID
) {
200 return_ACPI_STATUS(AE_OK
);
203 /* Get the AML pointer (method object) and buffer_field node */
205 extra_desc
= acpi_ns_get_secondary_object(obj_desc
);
206 node
= obj_desc
->buffer_field
.node
;
208 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
209 (ACPI_TYPE_BUFFER_FIELD
, node
, NULL
));
210 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "[%4.4s] BufferField Arg Init\n",
211 acpi_ut_get_node_name(node
)));
213 /* Execute the AML code for the term_arg arguments */
215 status
= acpi_ds_execute_arguments(node
, acpi_ns_get_parent_node(node
),
216 extra_desc
->extra
.aml_length
,
217 extra_desc
->extra
.aml_start
);
218 return_ACPI_STATUS(status
);
221 /*******************************************************************************
223 * FUNCTION: acpi_ds_get_bank_field_arguments
225 * PARAMETERS: obj_desc - A valid bank_field object
229 * DESCRIPTION: Get bank_field bank_value. This implements the late
230 * evaluation of these field attributes.
232 ******************************************************************************/
235 acpi_ds_get_bank_field_arguments(union acpi_operand_object
*obj_desc
)
237 union acpi_operand_object
*extra_desc
;
238 struct acpi_namespace_node
*node
;
241 ACPI_FUNCTION_TRACE_PTR(ds_get_bank_field_arguments
, obj_desc
);
243 if (obj_desc
->common
.flags
& AOPOBJ_DATA_VALID
) {
244 return_ACPI_STATUS(AE_OK
);
247 /* Get the AML pointer (method object) and bank_field node */
249 extra_desc
= acpi_ns_get_secondary_object(obj_desc
);
250 node
= obj_desc
->bank_field
.node
;
252 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
253 (ACPI_TYPE_LOCAL_BANK_FIELD
, node
, NULL
));
254 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "[%4.4s] BankField Arg Init\n",
255 acpi_ut_get_node_name(node
)));
257 /* Execute the AML code for the term_arg arguments */
259 status
= acpi_ds_execute_arguments(node
, acpi_ns_get_parent_node(node
),
260 extra_desc
->extra
.aml_length
,
261 extra_desc
->extra
.aml_start
);
262 return_ACPI_STATUS(status
);
265 /*******************************************************************************
267 * FUNCTION: acpi_ds_get_buffer_arguments
269 * PARAMETERS: obj_desc - A valid Buffer object
273 * DESCRIPTION: Get Buffer length and initializer byte list. This implements
274 * the late evaluation of these attributes.
276 ******************************************************************************/
278 acpi_status
acpi_ds_get_buffer_arguments(union acpi_operand_object
*obj_desc
)
280 struct acpi_namespace_node
*node
;
283 ACPI_FUNCTION_TRACE_PTR(ds_get_buffer_arguments
, obj_desc
);
285 if (obj_desc
->common
.flags
& AOPOBJ_DATA_VALID
) {
286 return_ACPI_STATUS(AE_OK
);
289 /* Get the Buffer node */
291 node
= obj_desc
->buffer
.node
;
294 "No pointer back to NS node in buffer obj %p",
296 return_ACPI_STATUS(AE_AML_INTERNAL
);
299 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Buffer Arg Init\n"));
301 /* Execute the AML code for the term_arg arguments */
303 status
= acpi_ds_execute_arguments(node
, node
,
304 obj_desc
->buffer
.aml_length
,
305 obj_desc
->buffer
.aml_start
);
306 return_ACPI_STATUS(status
);
309 /*******************************************************************************
311 * FUNCTION: acpi_ds_get_package_arguments
313 * PARAMETERS: obj_desc - A valid Package object
317 * DESCRIPTION: Get Package length and initializer byte list. This implements
318 * the late evaluation of these attributes.
320 ******************************************************************************/
322 acpi_status
acpi_ds_get_package_arguments(union acpi_operand_object
*obj_desc
)
324 struct acpi_namespace_node
*node
;
327 ACPI_FUNCTION_TRACE_PTR(ds_get_package_arguments
, obj_desc
);
329 if (obj_desc
->common
.flags
& AOPOBJ_DATA_VALID
) {
330 return_ACPI_STATUS(AE_OK
);
333 /* Get the Package node */
335 node
= obj_desc
->package
.node
;
338 "No pointer back to NS node in package %p",
340 return_ACPI_STATUS(AE_AML_INTERNAL
);
343 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Package Arg Init\n"));
345 /* Execute the AML code for the term_arg arguments */
347 status
= acpi_ds_execute_arguments(node
, node
,
348 obj_desc
->package
.aml_length
,
349 obj_desc
->package
.aml_start
);
350 return_ACPI_STATUS(status
);
353 /*****************************************************************************
355 * FUNCTION: acpi_ds_get_region_arguments
357 * PARAMETERS: obj_desc - A valid region object
361 * DESCRIPTION: Get region address and length. This implements the late
362 * evaluation of these region attributes.
364 ****************************************************************************/
366 acpi_status
acpi_ds_get_region_arguments(union acpi_operand_object
*obj_desc
)
368 struct acpi_namespace_node
*node
;
370 union acpi_operand_object
*extra_desc
;
372 ACPI_FUNCTION_TRACE_PTR(ds_get_region_arguments
, obj_desc
);
374 if (obj_desc
->region
.flags
& AOPOBJ_DATA_VALID
) {
375 return_ACPI_STATUS(AE_OK
);
378 extra_desc
= acpi_ns_get_secondary_object(obj_desc
);
380 return_ACPI_STATUS(AE_NOT_EXIST
);
383 /* Get the Region node */
385 node
= obj_desc
->region
.node
;
387 ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname
388 (ACPI_TYPE_REGION
, node
, NULL
));
390 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "[%4.4s] OpRegion Arg Init at AML %p\n",
391 acpi_ut_get_node_name(node
),
392 extra_desc
->extra
.aml_start
));
394 /* Execute the argument AML */
396 status
= acpi_ds_execute_arguments(node
, acpi_ns_get_parent_node(node
),
397 extra_desc
->extra
.aml_length
,
398 extra_desc
->extra
.aml_start
);
399 if (ACPI_FAILURE(status
)) {
400 return_ACPI_STATUS(status
);
403 /* Validate the region address/length via the host OS */
405 status
= acpi_os_validate_address(obj_desc
->region
.space_id
,
406 obj_desc
->region
.address
,
407 (acpi_size
) obj_desc
->region
.length
,
408 acpi_ut_get_node_name(node
));
410 if (ACPI_FAILURE(status
)) {
412 * Invalid address/length. We will emit an error message and mark
413 * the region as invalid, so that it will cause an additional error if
414 * it is ever used. Then return AE_OK.
416 ACPI_EXCEPTION((AE_INFO
, status
,
417 "During address validation of OpRegion [%4.4s]",
419 obj_desc
->common
.flags
|= AOPOBJ_INVALID
;
423 return_ACPI_STATUS(status
);
426 /*******************************************************************************
428 * FUNCTION: acpi_ds_initialize_region
430 * PARAMETERS: obj_handle - Region namespace node
434 * DESCRIPTION: Front end to ev_initialize_region
436 ******************************************************************************/
438 acpi_status
acpi_ds_initialize_region(acpi_handle obj_handle
)
440 union acpi_operand_object
*obj_desc
;
443 obj_desc
= acpi_ns_get_attached_object(obj_handle
);
445 /* Namespace is NOT locked */
447 status
= acpi_ev_initialize_region(obj_desc
, FALSE
);
451 /*******************************************************************************
453 * FUNCTION: acpi_ds_init_buffer_field
455 * PARAMETERS: aml_opcode - create_xxx_field
456 * obj_desc - buffer_field object
457 * buffer_desc - Host Buffer
458 * offset_desc - Offset into buffer
459 * length_desc - Length of field (CREATE_FIELD_OP only)
460 * result_desc - Where to store the result
464 * DESCRIPTION: Perform actual initialization of a buffer field
466 ******************************************************************************/
469 acpi_ds_init_buffer_field(u16 aml_opcode
,
470 union acpi_operand_object
*obj_desc
,
471 union acpi_operand_object
*buffer_desc
,
472 union acpi_operand_object
*offset_desc
,
473 union acpi_operand_object
*length_desc
,
474 union acpi_operand_object
*result_desc
)
482 ACPI_FUNCTION_TRACE_PTR(ds_init_buffer_field
, obj_desc
);
484 /* Host object must be a Buffer */
486 if (ACPI_GET_OBJECT_TYPE(buffer_desc
) != ACPI_TYPE_BUFFER
) {
488 "Target of Create Field is not a Buffer object - %s",
489 acpi_ut_get_object_type_name(buffer_desc
)));
491 status
= AE_AML_OPERAND_TYPE
;
496 * The last parameter to all of these opcodes (result_desc) started
497 * out as a name_string, and should therefore now be a NS node
498 * after resolution in acpi_ex_resolve_operands().
500 if (ACPI_GET_DESCRIPTOR_TYPE(result_desc
) != ACPI_DESC_TYPE_NAMED
) {
502 "(%s) destination not a NS Node [%s]",
503 acpi_ps_get_opcode_name(aml_opcode
),
504 acpi_ut_get_descriptor_name(result_desc
)));
506 status
= AE_AML_OPERAND_TYPE
;
510 offset
= (u32
) offset_desc
->integer
.value
;
513 * Setup the Bit offsets and counts, according to the opcode
515 switch (aml_opcode
) {
516 case AML_CREATE_FIELD_OP
:
518 /* Offset is in bits, count is in bits */
520 field_flags
= AML_FIELD_ACCESS_BYTE
;
522 bit_count
= (u32
) length_desc
->integer
.value
;
524 /* Must have a valid (>0) bit count */
526 if (bit_count
== 0) {
528 "Attempt to CreateField of length zero"));
529 status
= AE_AML_OPERAND_VALUE
;
534 case AML_CREATE_BIT_FIELD_OP
:
536 /* Offset is in bits, Field is one bit */
540 field_flags
= AML_FIELD_ACCESS_BYTE
;
543 case AML_CREATE_BYTE_FIELD_OP
:
545 /* Offset is in bytes, field is one byte */
547 bit_offset
= 8 * offset
;
549 field_flags
= AML_FIELD_ACCESS_BYTE
;
552 case AML_CREATE_WORD_FIELD_OP
:
554 /* Offset is in bytes, field is one word */
556 bit_offset
= 8 * offset
;
558 field_flags
= AML_FIELD_ACCESS_WORD
;
561 case AML_CREATE_DWORD_FIELD_OP
:
563 /* Offset is in bytes, field is one dword */
565 bit_offset
= 8 * offset
;
567 field_flags
= AML_FIELD_ACCESS_DWORD
;
570 case AML_CREATE_QWORD_FIELD_OP
:
572 /* Offset is in bytes, field is one qword */
574 bit_offset
= 8 * offset
;
576 field_flags
= AML_FIELD_ACCESS_QWORD
;
582 "Unknown field creation opcode %02x", aml_opcode
));
583 status
= AE_AML_BAD_OPCODE
;
587 /* Entire field must fit within the current length of the buffer */
589 if ((bit_offset
+ bit_count
) > (8 * (u32
) buffer_desc
->buffer
.length
)) {
591 "Field [%4.4s] at %d exceeds Buffer [%4.4s] size %d (bits)",
592 acpi_ut_get_node_name(result_desc
),
593 bit_offset
+ bit_count
,
594 acpi_ut_get_node_name(buffer_desc
->buffer
.node
),
595 8 * (u32
) buffer_desc
->buffer
.length
));
596 status
= AE_AML_BUFFER_LIMIT
;
601 * Initialize areas of the field object that are common to all fields
602 * For field_flags, use LOCK_RULE = 0 (NO_LOCK),
603 * UPDATE_RULE = 0 (UPDATE_PRESERVE)
605 status
= acpi_ex_prep_common_field_object(obj_desc
, field_flags
, 0,
606 bit_offset
, bit_count
);
607 if (ACPI_FAILURE(status
)) {
611 obj_desc
->buffer_field
.buffer_obj
= buffer_desc
;
613 /* Reference count for buffer_desc inherits obj_desc count */
615 buffer_desc
->common
.reference_count
= (u16
)
616 (buffer_desc
->common
.reference_count
+
617 obj_desc
->common
.reference_count
);
621 /* Always delete the operands */
623 acpi_ut_remove_reference(offset_desc
);
624 acpi_ut_remove_reference(buffer_desc
);
626 if (aml_opcode
== AML_CREATE_FIELD_OP
) {
627 acpi_ut_remove_reference(length_desc
);
630 /* On failure, delete the result descriptor */
632 if (ACPI_FAILURE(status
)) {
633 acpi_ut_remove_reference(result_desc
); /* Result descriptor */
635 /* Now the address and length are valid for this buffer_field */
637 obj_desc
->buffer_field
.flags
|= AOPOBJ_DATA_VALID
;
640 return_ACPI_STATUS(status
);
643 /*******************************************************************************
645 * FUNCTION: acpi_ds_eval_buffer_field_operands
647 * PARAMETERS: walk_state - Current walk
648 * Op - A valid buffer_field Op object
652 * DESCRIPTION: Get buffer_field Buffer and Index
653 * Called from acpi_ds_exec_end_op during buffer_field parse tree walk
655 ******************************************************************************/
658 acpi_ds_eval_buffer_field_operands(struct acpi_walk_state
*walk_state
,
659 union acpi_parse_object
*op
)
662 union acpi_operand_object
*obj_desc
;
663 struct acpi_namespace_node
*node
;
664 union acpi_parse_object
*next_op
;
666 ACPI_FUNCTION_TRACE_PTR(ds_eval_buffer_field_operands
, op
);
669 * This is where we evaluate the address and length fields of the
670 * create_xxx_field declaration
672 node
= op
->common
.node
;
674 /* next_op points to the op that holds the Buffer */
676 next_op
= op
->common
.value
.arg
;
678 /* Evaluate/create the address and length operands */
680 status
= acpi_ds_create_operands(walk_state
, next_op
);
681 if (ACPI_FAILURE(status
)) {
682 return_ACPI_STATUS(status
);
685 obj_desc
= acpi_ns_get_attached_object(node
);
687 return_ACPI_STATUS(AE_NOT_EXIST
);
690 /* Resolve the operands */
692 status
= acpi_ex_resolve_operands(op
->common
.aml_opcode
,
693 ACPI_WALK_OPERANDS
, walk_state
);
694 if (ACPI_FAILURE(status
)) {
695 ACPI_ERROR((AE_INFO
, "(%s) bad operand(s) (%X)",
696 acpi_ps_get_opcode_name(op
->common
.aml_opcode
),
699 return_ACPI_STATUS(status
);
702 /* Initialize the Buffer Field */
704 if (op
->common
.aml_opcode
== AML_CREATE_FIELD_OP
) {
706 /* NOTE: Slightly different operands for this opcode */
709 acpi_ds_init_buffer_field(op
->common
.aml_opcode
, obj_desc
,
710 walk_state
->operands
[0],
711 walk_state
->operands
[1],
712 walk_state
->operands
[2],
713 walk_state
->operands
[3]);
715 /* All other, create_xxx_field opcodes */
718 acpi_ds_init_buffer_field(op
->common
.aml_opcode
, obj_desc
,
719 walk_state
->operands
[0],
720 walk_state
->operands
[1], NULL
,
721 walk_state
->operands
[2]);
724 return_ACPI_STATUS(status
);
727 /*******************************************************************************
729 * FUNCTION: acpi_ds_eval_region_operands
731 * PARAMETERS: walk_state - Current walk
732 * Op - A valid region Op object
736 * DESCRIPTION: Get region address and length
737 * Called from acpi_ds_exec_end_op during op_region parse tree walk
739 ******************************************************************************/
742 acpi_ds_eval_region_operands(struct acpi_walk_state
*walk_state
,
743 union acpi_parse_object
*op
)
746 union acpi_operand_object
*obj_desc
;
747 union acpi_operand_object
*operand_desc
;
748 struct acpi_namespace_node
*node
;
749 union acpi_parse_object
*next_op
;
751 ACPI_FUNCTION_TRACE_PTR(ds_eval_region_operands
, op
);
754 * This is where we evaluate the address and length fields of the
755 * op_region declaration
757 node
= op
->common
.node
;
759 /* next_op points to the op that holds the space_iD */
761 next_op
= op
->common
.value
.arg
;
763 /* next_op points to address op */
765 next_op
= next_op
->common
.next
;
767 /* Evaluate/create the address and length operands */
769 status
= acpi_ds_create_operands(walk_state
, next_op
);
770 if (ACPI_FAILURE(status
)) {
771 return_ACPI_STATUS(status
);
774 /* Resolve the length and address operands to numbers */
776 status
= acpi_ex_resolve_operands(op
->common
.aml_opcode
,
777 ACPI_WALK_OPERANDS
, walk_state
);
778 if (ACPI_FAILURE(status
)) {
779 return_ACPI_STATUS(status
);
782 obj_desc
= acpi_ns_get_attached_object(node
);
784 return_ACPI_STATUS(AE_NOT_EXIST
);
788 * Get the length operand and save it
791 operand_desc
= walk_state
->operands
[walk_state
->num_operands
- 1];
793 obj_desc
->region
.length
= (u32
) operand_desc
->integer
.value
;
794 acpi_ut_remove_reference(operand_desc
);
797 * Get the address and save it
798 * (at top of stack - 1)
800 operand_desc
= walk_state
->operands
[walk_state
->num_operands
- 2];
802 obj_desc
->region
.address
= (acpi_physical_address
)
803 operand_desc
->integer
.value
;
804 acpi_ut_remove_reference(operand_desc
);
806 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "RgnObj %p Addr %8.8X%8.8X Len %X\n",
808 ACPI_FORMAT_NATIVE_UINT(obj_desc
->region
.address
),
809 obj_desc
->region
.length
));
811 /* Now the address and length are valid for this opregion */
813 obj_desc
->region
.flags
|= AOPOBJ_DATA_VALID
;
815 return_ACPI_STATUS(status
);
818 /*******************************************************************************
820 * FUNCTION: acpi_ds_eval_table_region_operands
822 * PARAMETERS: walk_state - Current walk
823 * Op - A valid region Op object
827 * DESCRIPTION: Get region address and length
828 * Called from acpi_ds_exec_end_op during data_table_region parse tree walk
830 ******************************************************************************/
833 acpi_ds_eval_table_region_operands(struct acpi_walk_state
*walk_state
,
834 union acpi_parse_object
*op
)
837 union acpi_operand_object
*obj_desc
;
838 union acpi_operand_object
**operand
;
839 struct acpi_namespace_node
*node
;
840 union acpi_parse_object
*next_op
;
842 struct acpi_table_header
*table
;
844 ACPI_FUNCTION_TRACE_PTR(ds_eval_table_region_operands
, op
);
847 * This is where we evaluate the signature_string and oem_iDString
848 * and oem_table_iDString of the data_table_region declaration
850 node
= op
->common
.node
;
852 /* next_op points to signature_string op */
854 next_op
= op
->common
.value
.arg
;
857 * Evaluate/create the signature_string and oem_iDString
858 * and oem_table_iDString operands
860 status
= acpi_ds_create_operands(walk_state
, next_op
);
861 if (ACPI_FAILURE(status
)) {
862 return_ACPI_STATUS(status
);
866 * Resolve the signature_string and oem_iDString
867 * and oem_table_iDString operands
869 status
= acpi_ex_resolve_operands(op
->common
.aml_opcode
,
870 ACPI_WALK_OPERANDS
, walk_state
);
871 if (ACPI_FAILURE(status
)) {
872 return_ACPI_STATUS(status
);
875 operand
= &walk_state
->operands
[0];
877 /* Find the ACPI table */
879 status
= acpi_tb_find_table(operand
[0]->string
.pointer
,
880 operand
[1]->string
.pointer
,
881 operand
[2]->string
.pointer
, &table_index
);
882 if (ACPI_FAILURE(status
)) {
883 return_ACPI_STATUS(status
);
886 acpi_ut_remove_reference(operand
[0]);
887 acpi_ut_remove_reference(operand
[1]);
888 acpi_ut_remove_reference(operand
[2]);
890 status
= acpi_get_table_by_index(table_index
, &table
);
891 if (ACPI_FAILURE(status
)) {
892 return_ACPI_STATUS(status
);
895 obj_desc
= acpi_ns_get_attached_object(node
);
897 return_ACPI_STATUS(AE_NOT_EXIST
);
900 obj_desc
->region
.address
=
901 (acpi_physical_address
) ACPI_TO_INTEGER(table
);
902 obj_desc
->region
.length
= table
->length
;
904 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "RgnObj %p Addr %8.8X%8.8X Len %X\n",
906 ACPI_FORMAT_NATIVE_UINT(obj_desc
->region
.address
),
907 obj_desc
->region
.length
));
909 /* Now the address and length are valid for this opregion */
911 obj_desc
->region
.flags
|= AOPOBJ_DATA_VALID
;
913 return_ACPI_STATUS(status
);
916 /*******************************************************************************
918 * FUNCTION: acpi_ds_eval_data_object_operands
920 * PARAMETERS: walk_state - Current walk
921 * Op - A valid data_object Op object
922 * obj_desc - data_object
926 * DESCRIPTION: Get the operands and complete the following data object types:
929 ******************************************************************************/
932 acpi_ds_eval_data_object_operands(struct acpi_walk_state
*walk_state
,
933 union acpi_parse_object
*op
,
934 union acpi_operand_object
*obj_desc
)
937 union acpi_operand_object
*arg_desc
;
940 ACPI_FUNCTION_TRACE(ds_eval_data_object_operands
);
942 /* The first operand (for all of these data objects) is the length */
945 * Set proper index into operand stack for acpi_ds_obj_stack_push
946 * invoked inside acpi_ds_create_operand.
948 walk_state
->operand_index
= walk_state
->num_operands
;
950 status
= acpi_ds_create_operand(walk_state
, op
->common
.value
.arg
, 1);
951 if (ACPI_FAILURE(status
)) {
952 return_ACPI_STATUS(status
);
955 status
= acpi_ex_resolve_operands(walk_state
->opcode
,
957 operands
[walk_state
->num_operands
-
959 if (ACPI_FAILURE(status
)) {
960 return_ACPI_STATUS(status
);
963 /* Extract length operand */
965 arg_desc
= walk_state
->operands
[walk_state
->num_operands
- 1];
966 length
= (u32
) arg_desc
->integer
.value
;
968 /* Cleanup for length operand */
970 status
= acpi_ds_obj_stack_pop(1, walk_state
);
971 if (ACPI_FAILURE(status
)) {
972 return_ACPI_STATUS(status
);
975 acpi_ut_remove_reference(arg_desc
);
978 * Create the actual data object
980 switch (op
->common
.aml_opcode
) {
984 acpi_ds_build_internal_buffer_obj(walk_state
, op
, length
,
989 case AML_VAR_PACKAGE_OP
:
992 acpi_ds_build_internal_package_obj(walk_state
, op
, length
,
997 return_ACPI_STATUS(AE_AML_BAD_OPCODE
);
1000 if (ACPI_SUCCESS(status
)) {
1002 * Return the object in the walk_state, unless the parent is a package -
1003 * in this case, the return object will be stored in the parse tree
1006 if ((!op
->common
.parent
) ||
1007 ((op
->common
.parent
->common
.aml_opcode
!= AML_PACKAGE_OP
) &&
1008 (op
->common
.parent
->common
.aml_opcode
!=
1010 && (op
->common
.parent
->common
.aml_opcode
!= AML_NAME_OP
))) {
1011 walk_state
->result_obj
= obj_desc
;
1015 return_ACPI_STATUS(status
);
1018 /*******************************************************************************
1020 * FUNCTION: acpi_ds_eval_bank_field_operands
1022 * PARAMETERS: walk_state - Current walk
1023 * Op - A valid bank_field Op object
1027 * DESCRIPTION: Get bank_field bank_value
1028 * Called from acpi_ds_exec_end_op during bank_field parse tree walk
1030 ******************************************************************************/
1033 acpi_ds_eval_bank_field_operands(struct acpi_walk_state
*walk_state
,
1034 union acpi_parse_object
*op
)
1037 union acpi_operand_object
*obj_desc
;
1038 union acpi_operand_object
*operand_desc
;
1039 struct acpi_namespace_node
*node
;
1040 union acpi_parse_object
*next_op
;
1041 union acpi_parse_object
*arg
;
1043 ACPI_FUNCTION_TRACE_PTR(ds_eval_bank_field_operands
, op
);
1046 * This is where we evaluate the bank_value field of the
1047 * bank_field declaration
1050 /* next_op points to the op that holds the Region */
1052 next_op
= op
->common
.value
.arg
;
1054 /* next_op points to the op that holds the Bank Register */
1056 next_op
= next_op
->common
.next
;
1058 /* next_op points to the op that holds the Bank Value */
1060 next_op
= next_op
->common
.next
;
1063 * Set proper index into operand stack for acpi_ds_obj_stack_push
1064 * invoked inside acpi_ds_create_operand.
1066 * We use walk_state->Operands[0] to store the evaluated bank_value
1068 walk_state
->operand_index
= 0;
1070 status
= acpi_ds_create_operand(walk_state
, next_op
, 0);
1071 if (ACPI_FAILURE(status
)) {
1072 return_ACPI_STATUS(status
);
1075 status
= acpi_ex_resolve_to_value(&walk_state
->operands
[0], walk_state
);
1076 if (ACPI_FAILURE(status
)) {
1077 return_ACPI_STATUS(status
);
1080 ACPI_DUMP_OPERANDS(ACPI_WALK_OPERANDS
,
1081 acpi_ps_get_opcode_name(op
->common
.aml_opcode
), 1);
1083 * Get the bank_value operand and save it
1086 operand_desc
= walk_state
->operands
[0];
1088 /* Arg points to the start Bank Field */
1090 arg
= acpi_ps_get_arg(op
, 4);
1093 /* Ignore OFFSET and ACCESSAS terms here */
1095 if (arg
->common
.aml_opcode
== AML_INT_NAMEDFIELD_OP
) {
1096 node
= arg
->common
.node
;
1098 obj_desc
= acpi_ns_get_attached_object(node
);
1100 return_ACPI_STATUS(AE_NOT_EXIST
);
1103 obj_desc
->bank_field
.value
=
1104 (u32
) operand_desc
->integer
.value
;
1107 /* Move to next field in the list */
1109 arg
= arg
->common
.next
;
1112 acpi_ut_remove_reference(operand_desc
);
1113 return_ACPI_STATUS(status
);
1116 /*******************************************************************************
1118 * FUNCTION: acpi_ds_exec_begin_control_op
1120 * PARAMETERS: walk_list - The list that owns the walk stack
1121 * Op - The control Op
1125 * DESCRIPTION: Handles all control ops encountered during control method
1128 ******************************************************************************/
1131 acpi_ds_exec_begin_control_op(struct acpi_walk_state
*walk_state
,
1132 union acpi_parse_object
*op
)
1134 acpi_status status
= AE_OK
;
1135 union acpi_generic_state
*control_state
;
1137 ACPI_FUNCTION_NAME(ds_exec_begin_control_op
);
1139 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
, "Op=%p Opcode=%2.2X State=%p\n", op
,
1140 op
->common
.aml_opcode
, walk_state
));
1142 switch (op
->common
.aml_opcode
) {
1147 * IF/WHILE: Create a new control state to manage these
1148 * constructs. We need to manage these as a stack, in order
1149 * to handle nesting.
1151 control_state
= acpi_ut_create_control_state();
1152 if (!control_state
) {
1153 status
= AE_NO_MEMORY
;
1157 * Save a pointer to the predicate for multiple executions
1160 control_state
->control
.aml_predicate_start
=
1161 walk_state
->parser_state
.aml
- 1;
1162 control_state
->control
.package_end
=
1163 walk_state
->parser_state
.pkg_end
;
1164 control_state
->control
.opcode
= op
->common
.aml_opcode
;
1166 /* Push the control state on this walk's control stack */
1168 acpi_ut_push_generic_state(&walk_state
->control_state
,
1174 /* Predicate is in the state object */
1175 /* If predicate is true, the IF was executed, ignore ELSE part */
1177 if (walk_state
->last_predicate
) {
1178 status
= AE_CTRL_TRUE
;
1194 /*******************************************************************************
1196 * FUNCTION: acpi_ds_exec_end_control_op
1198 * PARAMETERS: walk_list - The list that owns the walk stack
1199 * Op - The control Op
1203 * DESCRIPTION: Handles all control ops encountered during control method
1206 ******************************************************************************/
1209 acpi_ds_exec_end_control_op(struct acpi_walk_state
* walk_state
,
1210 union acpi_parse_object
* op
)
1212 acpi_status status
= AE_OK
;
1213 union acpi_generic_state
*control_state
;
1215 ACPI_FUNCTION_NAME(ds_exec_end_control_op
);
1217 switch (op
->common
.aml_opcode
) {
1220 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
, "[IF_OP] Op=%p\n", op
));
1223 * Save the result of the predicate in case there is an
1226 walk_state
->last_predicate
=
1227 (u8
) walk_state
->control_state
->common
.value
;
1230 * Pop the control state that was created at the start
1231 * of the IF and free it
1234 acpi_ut_pop_generic_state(&walk_state
->control_state
);
1235 acpi_ut_delete_generic_state(control_state
);
1244 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
, "[WHILE_OP] Op=%p\n", op
));
1246 if (walk_state
->control_state
->common
.value
) {
1248 /* Predicate was true, go back and evaluate it again! */
1250 status
= AE_CTRL_PENDING
;
1253 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
,
1254 "[WHILE_OP] termination! Op=%p\n", op
));
1256 /* Pop this control state and free it */
1259 acpi_ut_pop_generic_state(&walk_state
->control_state
);
1261 walk_state
->aml_last_while
=
1262 control_state
->control
.aml_predicate_start
;
1263 acpi_ut_delete_generic_state(control_state
);
1268 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
,
1269 "[RETURN_OP] Op=%p Arg=%p\n", op
,
1270 op
->common
.value
.arg
));
1273 * One optional operand -- the return value
1274 * It can be either an immediate operand or a result that
1275 * has been bubbled up the tree
1277 if (op
->common
.value
.arg
) {
1279 /* Since we have a real Return(), delete any implicit return */
1281 acpi_ds_clear_implicit_return(walk_state
);
1283 /* Return statement has an immediate operand */
1286 acpi_ds_create_operands(walk_state
,
1287 op
->common
.value
.arg
);
1288 if (ACPI_FAILURE(status
)) {
1293 * If value being returned is a Reference (such as
1294 * an arg or local), resolve it now because it may
1295 * cease to exist at the end of the method.
1298 acpi_ex_resolve_to_value(&walk_state
->operands
[0],
1300 if (ACPI_FAILURE(status
)) {
1305 * Get the return value and save as the last result
1306 * value. This is the only place where walk_state->return_desc
1307 * is set to anything other than zero!
1309 walk_state
->return_desc
= walk_state
->operands
[0];
1310 } else if (walk_state
->result_count
) {
1312 /* Since we have a real Return(), delete any implicit return */
1314 acpi_ds_clear_implicit_return(walk_state
);
1317 * The return value has come from a previous calculation.
1319 * If value being returned is a Reference (such as
1320 * an arg or local), resolve it now because it may
1321 * cease to exist at the end of the method.
1323 * Allow references created by the Index operator to return unchanged.
1325 if ((ACPI_GET_DESCRIPTOR_TYPE
1326 (walk_state
->results
->results
.obj_desc
[0]) ==
1327 ACPI_DESC_TYPE_OPERAND
)
1329 (ACPI_GET_OBJECT_TYPE
1330 (walk_state
->results
->results
.obj_desc
[0]) ==
1331 ACPI_TYPE_LOCAL_REFERENCE
)
1332 && ((walk_state
->results
->results
.obj_desc
[0])->
1333 reference
.class != ACPI_REFCLASS_INDEX
)) {
1335 acpi_ex_resolve_to_value(&walk_state
->
1339 if (ACPI_FAILURE(status
)) {
1344 walk_state
->return_desc
=
1345 walk_state
->results
->results
.obj_desc
[0];
1347 /* No return operand */
1349 if (walk_state
->num_operands
) {
1350 acpi_ut_remove_reference(walk_state
->
1354 walk_state
->operands
[0] = NULL
;
1355 walk_state
->num_operands
= 0;
1356 walk_state
->return_desc
= NULL
;
1359 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH
,
1360 "Completed RETURN_OP State=%p, RetVal=%p\n",
1361 walk_state
, walk_state
->return_desc
));
1363 /* End the control method execution right now */
1365 status
= AE_CTRL_TERMINATE
;
1370 /* Just do nothing! */
1373 case AML_BREAK_POINT_OP
:
1375 /* Call up to the OS service layer to handle this */
1378 acpi_os_signal(ACPI_SIGNAL_BREAKPOINT
,
1379 "Executed AML Breakpoint opcode");
1381 /* If and when it returns, all done. */
1386 case AML_CONTINUE_OP
: /* ACPI 2.0 */
1388 /* Pop and delete control states until we find a while */
1390 while (walk_state
->control_state
&&
1391 (walk_state
->control_state
->control
.opcode
!=
1394 acpi_ut_pop_generic_state(&walk_state
->
1396 acpi_ut_delete_generic_state(control_state
);
1399 /* No while found? */
1401 if (!walk_state
->control_state
) {
1402 return (AE_AML_NO_WHILE
);
1405 /* Was: walk_state->aml_last_while = walk_state->control_state->Control.aml_predicate_start; */
1407 walk_state
->aml_last_while
=
1408 walk_state
->control_state
->control
.package_end
;
1410 /* Return status depending on opcode */
1412 if (op
->common
.aml_opcode
== AML_BREAK_OP
) {
1413 status
= AE_CTRL_BREAK
;
1415 status
= AE_CTRL_CONTINUE
;
1421 ACPI_ERROR((AE_INFO
, "Unknown control opcode=%X Op=%p",
1422 op
->common
.aml_opcode
, op
));
1424 status
= AE_AML_BAD_OPCODE
;