1 /******************************************************************************
3 * Module Name: dswstate - Dispatcher parse tree walk management routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2006, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
44 #include <acpi/acpi.h>
45 #include <acpi/acparser.h>
46 #include <acpi/acdispat.h>
47 #include <acpi/acnamesp.h>
49 #define _COMPONENT ACPI_DISPATCHER
50 ACPI_MODULE_NAME("dswstate")
52 /* Local prototypes */
53 #ifdef ACPI_OBSOLETE_FUNCTIONS
55 acpi_ds_result_insert(void *object
,
56 u32 index
, struct acpi_walk_state
*walk_state
);
58 acpi_status
acpi_ds_obj_stack_delete_all(struct acpi_walk_state
*walk_state
);
61 acpi_ds_obj_stack_pop_object(union acpi_operand_object
**object
,
62 struct acpi_walk_state
*walk_state
);
64 void *acpi_ds_obj_stack_get_value(u32 index
,
65 struct acpi_walk_state
*walk_state
);
68 #ifdef ACPI_FUTURE_USAGE
70 /*******************************************************************************
72 * FUNCTION: acpi_ds_result_remove
74 * PARAMETERS: Object - Where to return the popped object
75 * Index - Where to extract the object
76 * walk_state - Current Walk state
80 * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In
81 * other words, this is a FIFO.
83 ******************************************************************************/
86 acpi_ds_result_remove(union acpi_operand_object
**object
,
87 u32 index
, struct acpi_walk_state
*walk_state
)
89 union acpi_generic_state
*state
;
91 ACPI_FUNCTION_NAME("ds_result_remove");
93 state
= walk_state
->results
;
95 ACPI_REPORT_ERROR(("No result object pushed! State=%p\n",
97 return (AE_NOT_EXIST
);
100 if (index
>= ACPI_OBJ_MAX_OPERAND
) {
101 ACPI_REPORT_ERROR(("Index out of range: %X State=%p Num=%X\n",
103 state
->results
.num_results
));
106 /* Check for a valid result object */
108 if (!state
->results
.obj_desc
[index
]) {
109 ACPI_REPORT_ERROR(("Null operand! State=%p #Ops=%X, Index=%X\n",
110 walk_state
, state
->results
.num_results
,
112 return (AE_AML_NO_RETURN_VALUE
);
115 /* Remove the object */
117 state
->results
.num_results
--;
119 *object
= state
->results
.obj_desc
[index
];
120 state
->results
.obj_desc
[index
] = NULL
;
122 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
123 "Obj=%p [%s] Index=%X State=%p Num=%X\n",
125 (*object
) ? acpi_ut_get_object_type_name(*object
) :
126 "NULL", index
, walk_state
,
127 state
->results
.num_results
));
132 #endif /* ACPI_FUTURE_USAGE */
134 /*******************************************************************************
136 * FUNCTION: acpi_ds_result_pop
138 * PARAMETERS: Object - Where to return the popped object
139 * walk_state - Current Walk state
143 * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In
144 * other words, this is a FIFO.
146 ******************************************************************************/
149 acpi_ds_result_pop(union acpi_operand_object
** object
,
150 struct acpi_walk_state
* walk_state
)
152 acpi_native_uint index
;
153 union acpi_generic_state
*state
;
155 ACPI_FUNCTION_NAME("ds_result_pop");
157 state
= walk_state
->results
;
162 if (!state
->results
.num_results
) {
163 ACPI_REPORT_ERROR(("Result stack is empty! State=%p\n",
165 return (AE_AML_NO_RETURN_VALUE
);
168 /* Remove top element */
170 state
->results
.num_results
--;
172 for (index
= ACPI_OBJ_NUM_OPERANDS
; index
; index
--) {
173 /* Check for a valid result object */
175 if (state
->results
.obj_desc
[index
- 1]) {
176 *object
= state
->results
.obj_desc
[index
- 1];
177 state
->results
.obj_desc
[index
- 1] = NULL
;
179 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
180 "Obj=%p [%s] Index=%X State=%p Num=%X\n",
183 acpi_ut_get_object_type_name(*object
)
184 : "NULL", (u32
) index
- 1, walk_state
,
185 state
->results
.num_results
));
191 ACPI_REPORT_ERROR(("No result objects! State=%p\n", walk_state
));
192 return (AE_AML_NO_RETURN_VALUE
);
195 /*******************************************************************************
197 * FUNCTION: acpi_ds_result_pop_from_bottom
199 * PARAMETERS: Object - Where to return the popped object
200 * walk_state - Current Walk state
204 * DESCRIPTION: Pop an object off the bottom of this walk's result stack. In
205 * other words, this is a FIFO.
207 ******************************************************************************/
210 acpi_ds_result_pop_from_bottom(union acpi_operand_object
** object
,
211 struct acpi_walk_state
* walk_state
)
213 acpi_native_uint index
;
214 union acpi_generic_state
*state
;
216 ACPI_FUNCTION_NAME("ds_result_pop_from_bottom");
218 state
= walk_state
->results
;
220 ACPI_REPORT_ERROR(("No result object pushed! State=%p\n",
222 return (AE_NOT_EXIST
);
225 if (!state
->results
.num_results
) {
226 ACPI_REPORT_ERROR(("No result objects! State=%p\n",
228 return (AE_AML_NO_RETURN_VALUE
);
231 /* Remove Bottom element */
233 *object
= state
->results
.obj_desc
[0];
235 /* Push entire stack down one element */
237 for (index
= 0; index
< state
->results
.num_results
; index
++) {
238 state
->results
.obj_desc
[index
] =
239 state
->results
.obj_desc
[index
+ 1];
242 state
->results
.num_results
--;
244 /* Check for a valid result object */
247 ACPI_REPORT_ERROR(("Null operand! State=%p #Ops=%X Index=%X\n",
248 walk_state
, state
->results
.num_results
,
250 return (AE_AML_NO_RETURN_VALUE
);
253 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Obj=%p [%s] Results=%p State=%p\n",
255 (*object
) ? acpi_ut_get_object_type_name(*object
) :
256 "NULL", state
, walk_state
));
261 /*******************************************************************************
263 * FUNCTION: acpi_ds_result_push
265 * PARAMETERS: Object - Where to return the popped object
266 * walk_state - Current Walk state
270 * DESCRIPTION: Push an object onto the current result stack
272 ******************************************************************************/
275 acpi_ds_result_push(union acpi_operand_object
* object
,
276 struct acpi_walk_state
* walk_state
)
278 union acpi_generic_state
*state
;
280 ACPI_FUNCTION_NAME("ds_result_push");
282 state
= walk_state
->results
;
284 ACPI_REPORT_ERROR(("No result stack frame during push\n"));
285 return (AE_AML_INTERNAL
);
288 if (state
->results
.num_results
== ACPI_OBJ_NUM_OPERANDS
) {
289 ACPI_REPORT_ERROR(("Result stack overflow: Obj=%p State=%p Num=%X\n", object
, walk_state
, state
->results
.num_results
));
290 return (AE_STACK_OVERFLOW
);
294 ACPI_REPORT_ERROR(("Null Object! Obj=%p State=%p Num=%X\n",
296 state
->results
.num_results
));
297 return (AE_BAD_PARAMETER
);
300 state
->results
.obj_desc
[state
->results
.num_results
] = object
;
301 state
->results
.num_results
++;
303 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Obj=%p [%s] State=%p Num=%X Cur=%X\n",
306 acpi_ut_get_object_type_name((union
307 acpi_operand_object
*)
309 walk_state
, state
->results
.num_results
,
310 walk_state
->current_result
));
315 /*******************************************************************************
317 * FUNCTION: acpi_ds_result_stack_push
319 * PARAMETERS: walk_state - Current Walk state
323 * DESCRIPTION: Push an object onto the walk_state result stack.
325 ******************************************************************************/
327 acpi_status
acpi_ds_result_stack_push(struct acpi_walk_state
* walk_state
)
329 union acpi_generic_state
*state
;
331 ACPI_FUNCTION_NAME("ds_result_stack_push");
333 state
= acpi_ut_create_generic_state();
335 return (AE_NO_MEMORY
);
338 state
->common
.data_type
= ACPI_DESC_TYPE_STATE_RESULT
;
339 acpi_ut_push_generic_state(&walk_state
->results
, state
);
341 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Results=%p State=%p\n",
347 /*******************************************************************************
349 * FUNCTION: acpi_ds_result_stack_pop
351 * PARAMETERS: walk_state - Current Walk state
355 * DESCRIPTION: Pop an object off of the walk_state result stack.
357 ******************************************************************************/
359 acpi_status
acpi_ds_result_stack_pop(struct acpi_walk_state
* walk_state
)
361 union acpi_generic_state
*state
;
363 ACPI_FUNCTION_NAME("ds_result_stack_pop");
365 /* Check for stack underflow */
367 if (walk_state
->results
== NULL
) {
368 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Underflow - State=%p\n",
370 return (AE_AML_NO_OPERAND
);
373 state
= acpi_ut_pop_generic_state(&walk_state
->results
);
375 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
376 "Result=%p remaining_results=%X State=%p\n",
377 state
, state
->results
.num_results
, walk_state
));
379 acpi_ut_delete_generic_state(state
);
384 /*******************************************************************************
386 * FUNCTION: acpi_ds_obj_stack_push
388 * PARAMETERS: Object - Object to push
389 * walk_state - Current Walk state
393 * DESCRIPTION: Push an object onto this walk's object/operand stack
395 ******************************************************************************/
398 acpi_ds_obj_stack_push(void *object
, struct acpi_walk_state
* walk_state
)
400 ACPI_FUNCTION_NAME("ds_obj_stack_push");
402 /* Check for stack overflow */
404 if (walk_state
->num_operands
>= ACPI_OBJ_NUM_OPERANDS
) {
405 ACPI_REPORT_ERROR(("Object stack overflow! Obj=%p State=%p #Ops=%X\n", object
, walk_state
, walk_state
->num_operands
));
406 return (AE_STACK_OVERFLOW
);
409 /* Put the object onto the stack */
411 walk_state
->operands
[walk_state
->num_operands
] = object
;
412 walk_state
->num_operands
++;
414 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Obj=%p [%s] State=%p #Ops=%X\n",
416 acpi_ut_get_object_type_name((union
417 acpi_operand_object
*)
419 walk_state
->num_operands
));
424 /*******************************************************************************
426 * FUNCTION: acpi_ds_obj_stack_pop
428 * PARAMETERS: pop_count - Number of objects/entries to pop
429 * walk_state - Current Walk state
433 * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
434 * deleted by this routine.
436 ******************************************************************************/
439 acpi_ds_obj_stack_pop(u32 pop_count
, struct acpi_walk_state
* walk_state
)
443 ACPI_FUNCTION_NAME("ds_obj_stack_pop");
445 for (i
= 0; i
< pop_count
; i
++) {
446 /* Check for stack underflow */
448 if (walk_state
->num_operands
== 0) {
449 ACPI_REPORT_ERROR(("Object stack underflow! Count=%X State=%p #Ops=%X\n", pop_count
, walk_state
, walk_state
->num_operands
));
450 return (AE_STACK_UNDERFLOW
);
453 /* Just set the stack entry to null */
455 walk_state
->num_operands
--;
456 walk_state
->operands
[walk_state
->num_operands
] = NULL
;
459 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Count=%X State=%p #Ops=%X\n",
460 pop_count
, walk_state
, walk_state
->num_operands
));
465 /*******************************************************************************
467 * FUNCTION: acpi_ds_obj_stack_pop_and_delete
469 * PARAMETERS: pop_count - Number of objects/entries to pop
470 * walk_state - Current Walk state
474 * DESCRIPTION: Pop this walk's object stack and delete each object that is
477 ******************************************************************************/
480 acpi_ds_obj_stack_pop_and_delete(u32 pop_count
,
481 struct acpi_walk_state
* walk_state
)
484 union acpi_operand_object
*obj_desc
;
486 ACPI_FUNCTION_NAME("ds_obj_stack_pop_and_delete");
488 for (i
= 0; i
< pop_count
; i
++) {
489 /* Check for stack underflow */
491 if (walk_state
->num_operands
== 0) {
492 ACPI_REPORT_ERROR(("Object stack underflow! Count=%X State=%p #Ops=%X\n", pop_count
, walk_state
, walk_state
->num_operands
));
493 return (AE_STACK_UNDERFLOW
);
496 /* Pop the stack and delete an object if present in this stack entry */
498 walk_state
->num_operands
--;
499 obj_desc
= walk_state
->operands
[walk_state
->num_operands
];
501 acpi_ut_remove_reference(walk_state
->
502 operands
[walk_state
->
504 walk_state
->operands
[walk_state
->num_operands
] = NULL
;
508 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Count=%X State=%p #Ops=%X\n",
509 pop_count
, walk_state
, walk_state
->num_operands
));
514 /*******************************************************************************
516 * FUNCTION: acpi_ds_get_current_walk_state
518 * PARAMETERS: Thread - Get current active state for this Thread
520 * RETURN: Pointer to the current walk state
522 * DESCRIPTION: Get the walk state that is at the head of the list (the "current"
525 ******************************************************************************/
527 struct acpi_walk_state
*acpi_ds_get_current_walk_state(struct acpi_thread_state
530 ACPI_FUNCTION_NAME("ds_get_current_walk_state");
536 ACPI_DEBUG_PRINT((ACPI_DB_PARSE
, "Current walk_state %p\n",
537 thread
->walk_state_list
));
539 return (thread
->walk_state_list
);
542 /*******************************************************************************
544 * FUNCTION: acpi_ds_push_walk_state
546 * PARAMETERS: walk_state - State to push
547 * Thread - Thread state object
551 * DESCRIPTION: Place the Thread state at the head of the state list.
553 ******************************************************************************/
556 acpi_ds_push_walk_state(struct acpi_walk_state
*walk_state
,
557 struct acpi_thread_state
*thread
)
559 ACPI_FUNCTION_TRACE("ds_push_walk_state");
561 walk_state
->next
= thread
->walk_state_list
;
562 thread
->walk_state_list
= walk_state
;
567 /*******************************************************************************
569 * FUNCTION: acpi_ds_pop_walk_state
571 * PARAMETERS: Thread - Current thread state
573 * RETURN: A walk_state object popped from the thread's stack
575 * DESCRIPTION: Remove and return the walkstate object that is at the head of
576 * the walk stack for the given walk list. NULL indicates that
579 ******************************************************************************/
581 struct acpi_walk_state
*acpi_ds_pop_walk_state(struct acpi_thread_state
*thread
)
583 struct acpi_walk_state
*walk_state
;
585 ACPI_FUNCTION_TRACE("ds_pop_walk_state");
587 walk_state
= thread
->walk_state_list
;
590 /* Next walk state becomes the current walk state */
592 thread
->walk_state_list
= walk_state
->next
;
595 * Don't clear the NEXT field, this serves as an indicator
596 * that there is a parent WALK STATE
597 * Do Not: walk_state->Next = NULL;
601 return_PTR(walk_state
);
604 /*******************************************************************************
606 * FUNCTION: acpi_ds_create_walk_state
608 * PARAMETERS: owner_id - ID for object creation
609 * Origin - Starting point for this walk
610 * mth_desc - Method object
611 * Thread - Current thread state
613 * RETURN: Pointer to the new walk state.
615 * DESCRIPTION: Allocate and initialize a new walk state. The current walk
616 * state is set to this new state.
618 ******************************************************************************/
620 struct acpi_walk_state
*acpi_ds_create_walk_state(acpi_owner_id owner_id
,
621 union acpi_parse_object
623 union acpi_operand_object
625 struct acpi_thread_state
628 struct acpi_walk_state
*walk_state
;
631 ACPI_FUNCTION_TRACE("ds_create_walk_state");
633 walk_state
= ACPI_MEM_CALLOCATE(sizeof(struct acpi_walk_state
));
638 walk_state
->data_type
= ACPI_DESC_TYPE_WALK
;
639 walk_state
->owner_id
= owner_id
;
640 walk_state
->origin
= origin
;
641 walk_state
->method_desc
= mth_desc
;
642 walk_state
->thread
= thread
;
644 walk_state
->parser_state
.start_op
= origin
;
646 /* Init the method args/local */
648 #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
649 acpi_ds_method_data_init(walk_state
);
652 /* Create an initial result stack entry */
654 status
= acpi_ds_result_stack_push(walk_state
);
655 if (ACPI_FAILURE(status
)) {
656 ACPI_MEM_FREE(walk_state
);
660 /* Put the new state at the head of the walk list */
663 acpi_ds_push_walk_state(walk_state
, thread
);
666 return_PTR(walk_state
);
669 /*******************************************************************************
671 * FUNCTION: acpi_ds_init_aml_walk
673 * PARAMETERS: walk_state - New state to be initialized
674 * Op - Current parse op
675 * method_node - Control method NS node, if any
676 * aml_start - Start of AML
677 * aml_length - Length of AML
678 * Info - Method info block (params, etc.)
679 * pass_number - 1, 2, or 3
683 * DESCRIPTION: Initialize a walk state for a pass 1 or 2 parse tree walk
685 ******************************************************************************/
688 acpi_ds_init_aml_walk(struct acpi_walk_state
*walk_state
,
689 union acpi_parse_object
*op
,
690 struct acpi_namespace_node
*method_node
,
693 struct acpi_parameter_info
*info
, u8 pass_number
)
696 struct acpi_parse_state
*parser_state
= &walk_state
->parser_state
;
697 union acpi_parse_object
*extra_op
;
699 ACPI_FUNCTION_TRACE("ds_init_aml_walk");
701 walk_state
->parser_state
.aml
=
702 walk_state
->parser_state
.aml_start
= aml_start
;
703 walk_state
->parser_state
.aml_end
=
704 walk_state
->parser_state
.pkg_end
= aml_start
+ aml_length
;
706 /* The next_op of the next_walk will be the beginning of the method */
708 walk_state
->next_op
= NULL
;
709 walk_state
->pass_number
= pass_number
;
712 if (info
->parameter_type
== ACPI_PARAM_GPE
) {
713 walk_state
->gpe_event_info
=
714 ACPI_CAST_PTR(struct acpi_gpe_event_info
,
717 walk_state
->params
= info
->parameters
;
718 walk_state
->caller_return_desc
= &info
->return_object
;
722 status
= acpi_ps_init_scope(&walk_state
->parser_state
, op
);
723 if (ACPI_FAILURE(status
)) {
724 return_ACPI_STATUS(status
);
728 walk_state
->parser_state
.start_node
= method_node
;
729 walk_state
->walk_type
= ACPI_WALK_METHOD
;
730 walk_state
->method_node
= method_node
;
731 walk_state
->method_desc
=
732 acpi_ns_get_attached_object(method_node
);
734 /* Push start scope on scope stack and make it current */
737 acpi_ds_scope_stack_push(method_node
, ACPI_TYPE_METHOD
,
739 if (ACPI_FAILURE(status
)) {
740 return_ACPI_STATUS(status
);
743 /* Init the method arguments */
745 status
= acpi_ds_method_data_init_args(walk_state
->params
,
746 ACPI_METHOD_NUM_ARGS
,
748 if (ACPI_FAILURE(status
)) {
749 return_ACPI_STATUS(status
);
753 * Setup the current scope.
754 * Find a Named Op that has a namespace node associated with it.
755 * search upwards from this Op. Current scope is the first
756 * Op with a namespace node.
758 extra_op
= parser_state
->start_op
;
759 while (extra_op
&& !extra_op
->common
.node
) {
760 extra_op
= extra_op
->common
.parent
;
764 parser_state
->start_node
= NULL
;
766 parser_state
->start_node
= extra_op
->common
.node
;
769 if (parser_state
->start_node
) {
770 /* Push start scope on scope stack and make it current */
773 acpi_ds_scope_stack_push(parser_state
->start_node
,
774 parser_state
->start_node
->
776 if (ACPI_FAILURE(status
)) {
777 return_ACPI_STATUS(status
);
782 status
= acpi_ds_init_callbacks(walk_state
, pass_number
);
783 return_ACPI_STATUS(status
);
786 /*******************************************************************************
788 * FUNCTION: acpi_ds_delete_walk_state
790 * PARAMETERS: walk_state - State to delete
794 * DESCRIPTION: Delete a walk state including all internal data structures
796 ******************************************************************************/
798 void acpi_ds_delete_walk_state(struct acpi_walk_state
*walk_state
)
800 union acpi_generic_state
*state
;
802 ACPI_FUNCTION_TRACE_PTR("ds_delete_walk_state", walk_state
);
808 if (walk_state
->data_type
!= ACPI_DESC_TYPE_WALK
) {
809 ACPI_REPORT_ERROR(("%p is not a valid walk state\n",
814 if (walk_state
->parser_state
.scope
) {
815 ACPI_REPORT_ERROR(("%p walk still has a scope list\n",
819 /* Always must free any linked control states */
821 while (walk_state
->control_state
) {
822 state
= walk_state
->control_state
;
823 walk_state
->control_state
= state
->common
.next
;
825 acpi_ut_delete_generic_state(state
);
828 /* Always must free any linked parse states */
830 while (walk_state
->scope_info
) {
831 state
= walk_state
->scope_info
;
832 walk_state
->scope_info
= state
->common
.next
;
834 acpi_ut_delete_generic_state(state
);
837 /* Always must free any stacked result states */
839 while (walk_state
->results
) {
840 state
= walk_state
->results
;
841 walk_state
->results
= state
->common
.next
;
843 acpi_ut_delete_generic_state(state
);
846 ACPI_MEM_FREE(walk_state
);
850 #ifdef ACPI_OBSOLETE_FUNCTIONS
851 /*******************************************************************************
853 * FUNCTION: acpi_ds_result_insert
855 * PARAMETERS: Object - Object to push
856 * Index - Where to insert the object
857 * walk_state - Current Walk state
861 * DESCRIPTION: Insert an object onto this walk's result stack
863 ******************************************************************************/
866 acpi_ds_result_insert(void *object
,
867 u32 index
, struct acpi_walk_state
*walk_state
)
869 union acpi_generic_state
*state
;
871 ACPI_FUNCTION_NAME("ds_result_insert");
873 state
= walk_state
->results
;
875 ACPI_REPORT_ERROR(("No result object pushed! State=%p\n",
877 return (AE_NOT_EXIST
);
880 if (index
>= ACPI_OBJ_NUM_OPERANDS
) {
881 ACPI_REPORT_ERROR(("Index out of range: %X Obj=%p State=%p Num=%X\n", index
, object
, walk_state
, state
->results
.num_results
));
882 return (AE_BAD_PARAMETER
);
886 ACPI_REPORT_ERROR(("Null Object! Index=%X Obj=%p State=%p Num=%X\n", index
, object
, walk_state
, state
->results
.num_results
));
887 return (AE_BAD_PARAMETER
);
890 state
->results
.obj_desc
[index
] = object
;
891 state
->results
.num_results
++;
893 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
,
894 "Obj=%p [%s] State=%p Num=%X Cur=%X\n",
897 acpi_ut_get_object_type_name((union
898 acpi_operand_object
*)
900 walk_state
, state
->results
.num_results
,
901 walk_state
->current_result
));
906 /*******************************************************************************
908 * FUNCTION: acpi_ds_obj_stack_delete_all
910 * PARAMETERS: walk_state - Current Walk state
914 * DESCRIPTION: Clear the object stack by deleting all objects that are on it.
915 * Should be used with great care, if at all!
917 ******************************************************************************/
919 acpi_status
acpi_ds_obj_stack_delete_all(struct acpi_walk_state
* walk_state
)
923 ACPI_FUNCTION_TRACE_PTR("ds_obj_stack_delete_all", walk_state
);
925 /* The stack size is configurable, but fixed */
927 for (i
= 0; i
< ACPI_OBJ_NUM_OPERANDS
; i
++) {
928 if (walk_state
->operands
[i
]) {
929 acpi_ut_remove_reference(walk_state
->operands
[i
]);
930 walk_state
->operands
[i
] = NULL
;
934 return_ACPI_STATUS(AE_OK
);
937 /*******************************************************************************
939 * FUNCTION: acpi_ds_obj_stack_pop_object
941 * PARAMETERS: Object - Where to return the popped object
942 * walk_state - Current Walk state
946 * DESCRIPTION: Pop this walk's object stack. Objects on the stack are NOT
947 * deleted by this routine.
949 ******************************************************************************/
952 acpi_ds_obj_stack_pop_object(union acpi_operand_object
**object
,
953 struct acpi_walk_state
*walk_state
)
955 ACPI_FUNCTION_NAME("ds_obj_stack_pop_object");
957 /* Check for stack underflow */
959 if (walk_state
->num_operands
== 0) {
960 ACPI_REPORT_ERROR(("Missing operand/stack empty! State=%p #Ops=%X\n", walk_state
, walk_state
->num_operands
));
962 return (AE_AML_NO_OPERAND
);
967 walk_state
->num_operands
--;
969 /* Check for a valid operand */
971 if (!walk_state
->operands
[walk_state
->num_operands
]) {
972 ACPI_REPORT_ERROR(("Null operand! State=%p #Ops=%X\n",
973 walk_state
, walk_state
->num_operands
));
975 return (AE_AML_NO_OPERAND
);
978 /* Get operand and set stack entry to null */
980 *object
= walk_state
->operands
[walk_state
->num_operands
];
981 walk_state
->operands
[walk_state
->num_operands
] = NULL
;
983 ACPI_DEBUG_PRINT((ACPI_DB_EXEC
, "Obj=%p [%s] State=%p #Ops=%X\n",
984 *object
, acpi_ut_get_object_type_name(*object
),
985 walk_state
, walk_state
->num_operands
));
990 /*******************************************************************************
992 * FUNCTION: acpi_ds_obj_stack_get_value
994 * PARAMETERS: Index - Stack index whose value is desired. Based
995 * on the top of the stack (index=0 == top)
996 * walk_state - Current Walk state
998 * RETURN: Pointer to the requested operand
1000 * DESCRIPTION: Retrieve an object from this walk's operand stack. Index must
1001 * be within the range of the current stack pointer.
1003 ******************************************************************************/
1005 void *acpi_ds_obj_stack_get_value(u32 index
, struct acpi_walk_state
*walk_state
)
1008 ACPI_FUNCTION_TRACE_PTR("ds_obj_stack_get_value", walk_state
);
1010 /* Can't do it if the stack is empty */
1012 if (walk_state
->num_operands
== 0) {
1016 /* or if the index is past the top of the stack */
1018 if (index
> (walk_state
->num_operands
- (u32
) 1)) {
1022 return_PTR(walk_state
->
1023 operands
[(acpi_native_uint
) (walk_state
->num_operands
- 1) -